[PATCH 14/14] regression-recipes: update LNST-PerfRepo integration

[Ondrej Lichtner]

From: Ondrej Lichtner <olichtne(a)redhat.com&gt;

This updates all regression recipes to use the new LNST-PerfRepo Task
API which greatly simplifies them.

Signed-off-by: Ondrej Lichtner <olichtne(a)redhat.com&gt;
---
 recipes/regression_tests/phase1/3_vlans.py         | 235 ++++-------
 .../regression_tests/phase1/3_vlans_over_bond.py   | 236 ++++-------
 recipes/regression_tests/phase1/bonding_test.py    | 215 ++++------
 .../phase1/virtual_bridge_2_vlans_over_bond.py     | 213 +++-------
 .../phase1/virtual_bridge_vlan_in_guest.py         | 216 +++-------
 .../phase1/virtual_bridge_vlan_in_host.py          | 216 +++-------
 .../regression_tests/phase2/3_vlans_over_team.py   | 231 ++++-------
 recipes/regression_tests/phase2/team_test.py       | 451 +++++++--------------
 ...l_ovs_bridge_2_vlans_over_active_backup_bond.py | 214 +++-------
 .../phase2/virtual_ovs_bridge_vlan_in_guest.py     | 214 +++-------
 .../phase2/virtual_ovs_bridge_vlan_in_host.py      | 215 ++++------
 11 files changed, 843 insertions(+), 1813 deletions(-)

diff --git a/recipes/regression_tests/phase1/3_vlans.py
b/recipes/regression_tests/phase1/3_vlans.py
index b3c3966..3fdf60c 100644
--- a/recipes/regression_tests/phase1/3_vlans.py
+++ b/recipes/regression_tests/phase1/3_vlans.py
@@ -1,31 +1,17 @@
 import logging
 from lnst.Controller.Task import ctl
-from lnst.Controller.PerfRepoUtils import parse_id_mapping, get_id
+from lnst.Controller.PerfRepoUtils import netperf_baseline_template
+from lnst.Controller.PerfRepoUtils import netperf_result_template
 
 # ------
 # SETUP
 # ------
 
 mapping_file = ctl.get_alias("mapping_file")
-mapping = parse_id_mapping(mapping_file)
+perf_api = ctl.connect_PerfRepo(mapping_file)
 
 product_name = ctl.get_alias("product_name")
 
-tcp_ipv4_id = get_id(mapping, "tcp_ipv4_id")
-tcp_ipv6_id = get_id(mapping, "tcp_ipv6_id")
-udp_ipv4_id = get_id(mapping, "udp_ipv4_id")
-udp_ipv6_id = get_id(mapping, "udp_ipv6_id")
-
-if tcp_ipv4_id is not None or\
-   tcp_ipv6_id is not None or\
-   udp_ipv4_id is not None or\
-   udp_ipv6_id is not None:
-    perf_api = ctl.connect_PerfRepo()
-    logging.info("PerfRepo support enabled for this run.")
-else:
-    logging.info("PerfRepo support disabled for this run.")
-
-
 m1 = ctl.get_host("testmachine1")
 m2 = ctl.get_host("testmachine2")
 
@@ -145,169 +131,100 @@ for vlan1 in vlans:
                         # Ping test
                         m1.run(ping_mod)
 
-                        # prepare PerfRepo result for tcp
-                        result_tcp = None
-                        result_udp = None
-                        if tcp_ipv4_id is not None:
-                            result_tcp = perf_api.new_result(tcp_ipv4_id,
"tcp_ipv4_result")
-                            result_tcp.set_parameter(offload, state)
-                            result_tcp.set_parameter('netperf_server_on_vlan',
vlan1)
-                            result_tcp.set_parameter('netperf_client_on_vlan',
vlan2)
-                            if product_name is not None:
-                                result_tcp.set_tag(product_name)
-                            res_hash =
result_tcp.generate_hash(['kernel_release',
-                                                                
'redhat_release'])
-                            result_tcp.set_tag(res_hash)
-
-                            baseline = None
-                            report_id = get_id(mapping, res_hash)
-                            if report_id is not None:
-                                baseline = perf_api.get_baseline(report_id)
-
-                            if baseline is not None:
-                                baseline_throughput =
baseline.get_value('throughput').get_result()
-                                baseline_deviation =
baseline.get_value('throughput_deviation').get_result()
-                                netperf_cli_tcp.update_options({'threshold':
'%s bits/sec' % baseline_throughput,
-                                                               
'threshold_deviation': '%s bits/sec' % baseline_deviation})
-
-                        # prepare PerfRepo result for udp
-                        if udp_ipv4_id is not None:
-                            result_udp = perf_api.new_result(udp_ipv4_id,
"udp_ipv4_result")
-                            result_udp.set_parameter(offload, state)
-                            result_udp.set_parameter('netperf_server_on_vlan',
vlan1)
-                            result_udp.set_parameter('netperf_client_on_vlan',
vlan2)
-                            if product_name is not None:
-                                result_udp.set_tag(product_name)
-                            res_hash =
result_udp.generate_hash(['kernel_release',
-                                                                
'redhat_release'])
-                            result_udp.set_tag(res_hash)
-
-                            baseline = None
-                            report_id = get_id(mapping, res_hash)
-                            if report_id is not None:
-                                baseline = perf_api.get_baseline(report_id)
-
-                            if baseline is not None:
-                                baseline_throughput =
baseline.get_value('throughput').get_result()
-                                baseline_deviation =
baseline.get_value('throughput_deviation').get_result()
-                                netperf_cli_udp.update_options({'threshold':
'%s bits/sec' % baseline_throughput,
-                                                               
'threshold_deviation': '%s bits/sec' % baseline_deviation})
-
-
                         # Netperf test (both TCP and UDP)
                         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'])
+                        result_tcp.set_parameter(offload, state)
+                        result_tcp.set_parameter('netperf_server_on_vlan',
vlan1)
+                        result_tcp.set_parameter('netperf_client_on_vlan',
vlan2)
+                        result_tcp.add_tag(product_name)
+
+                        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)
+                        perf_api.save_result(result_tcp)
+
+                        result_udp = perf_api.new_result("udp_ipv4_id",
+                                                         "udp_ipv4_result",
+                                                         hash_ignore=[
+                                                             'kernel_release',
+                                                             'redhat_release'])
+                        result_udp.set_parameter(offload, state)
+                        result_udp.set_parameter('netperf_server_on_vlan',
vlan1)
+                        result_udp.set_parameter('netperf_client_on_vlan',
vlan2)
+                        result_udp.add_tag(product_name)
+
+                        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)
-                        srv_proc.intr()
 
-                        if result_tcp is not None and\
-                           tcp_res_data.get_result() is not None and\
-                           tcp_res_data.get_result()['res_data'] is not None:
-                            rate =
tcp_res_data.get_result()['res_data']['rate']
-                            deviation =
tcp_res_data.get_result()['res_data']['rate_deviation']
-
-                            result_tcp.add_value('throughput', rate)
-                            result_tcp.add_value('throughput_min', rate -
deviation)
-                            result_tcp.add_value('throughput_max', rate +
deviation)
-                            result_tcp.add_value('throughput_deviation',
deviation)
-                            perf_api.save_result(result_tcp)
-
-                        if result_udp is not None and udp_res_data.get_result() is not
None and\
-                           udp_res_data.get_result()['res_data'] is not None:
-                            rate =
udp_res_data.get_result()['res_data']['rate']
-                            deviation =
udp_res_data.get_result()['res_data']['rate_deviation']
-
-                            result_udp.add_value('throughput', rate)
-                            result_udp.add_value('throughput_min', rate -
deviation)
-                            result_udp.add_value('throughput_max', rate +
deviation)
-                            result_udp.add_value('throughput_deviation',
deviation)
-                            perf_api.save_result(result_udp)
+                        netperf_result_template(result_udp, udp_res_data)
+                        perf_api.save_result(result_udp)
+
+                        srv_proc.intr()
 
                     if ipv in [ 'ipv6', 'both' ]:
                         # Ping test
                         m1.run(ping_mod6)
 
-                        # prepare PerfRepo result for tcp ipv6
-                        result_tcp = None
-                        result_udp = None
-                        if tcp_ipv6_id is not None:
-                            result_tcp = perf_api.new_result(tcp_ipv6_id,
"tcp_ipv6_result")
-                            result_tcp.set_parameter(offload, state)
-                            result_tcp.set_parameter('netperf_server_on_vlan',
vlan1)
-                            result_tcp.set_parameter('netperf_client_on_vlan',
vlan2)
-                            if product_name is not None:
-                                result_tcp.set_tag(product_name)
-                            res_hash =
result_tcp.generate_hash(['kernel_release',
-                                                                
'redhat_release'])
-                            result_tcp.set_tag(res_hash)
-
-                            baseline = None
-                            report_id = get_id(mapping, res_hash)
-                            if report_id is not None:
-                                baseline = perf_api.get_baseline(report_id)
-
-                            if baseline is not None:
-                                baseline_throughput =
baseline.get_value('throughput').get_result()
-                                baseline_deviation =
baseline.get_value('throughput_deviation').get_result()
-                                netperf_cli_tcp.update_options({'threshold':
'%s bits/sec' % baseline_throughput,
-                                                               
'threshold_deviation': '%s bits/sec' % baseline_deviation})
-
-                        # prepare PerfRepo result for udp ipv6
-                        if udp_ipv6_id is not None:
-                            result_udp = perf_api.new_result(udp_ipv6_id,
"udp_ipv6_result")
-                            result_udp.set_parameter(offload, state)
-                            result_udp.set_parameter('netperf_server_on_vlan',
vlan1)
-                            result_udp.set_parameter('netperf_client_on_vlan',
vlan2)
-                            if product_name is not None:
-                                result_udp.set_tag(product_name)
-                            res_hash =
result_udp.generate_hash(['kernel_release',
-                                                                
'redhat_release'])
-                            result_udp.set_tag(res_hash)
-
-                            baseline = None
-                            report_id = get_id(mapping, res_hash)
-                            if report_id is not None:
-                                baseline = perf_api.get_baseline(report_id)
-
-                            if baseline is not None:
-                                baseline_throughput =
baseline.get_value('throughput').get_result()
-                                baseline_deviation =
baseline.get_value('throughput_deviation').get_result()
-                                netperf_cli_udp.update_options({'threshold':
'%s bits/sec' % baseline_throughput,
-                                                               
'threshold_deviation': '%s bits/sec' % baseline_deviation})
-
                         # Netperf test (both TCP and UDP)
                         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'])
+                        result_tcp.set_parameter(offload, state)
+                        result_tcp.set_parameter('netperf_server_on_vlan',
vlan1)
+                        result_tcp.set_parameter('netperf_client_on_vlan',
vlan2)
+                        result_tcp.set_tag(product_name)
+
+                        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)
+                        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'])
+                        result_udp.set_parameter(offload, state)
+                        result_udp.set_parameter('netperf_server_on_vlan',
vlan1)
+                        result_udp.set_parameter('netperf_client_on_vlan',
vlan2)
+                        result_udp.set_tag(product_name)
+
+                        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)
-                        srv_proc.intr()
 
-                        if result_tcp is not None and tcp_res_data.get_result() is not
None and\
-                           tcp_res_data.get_result()['res_data'] is not None:
-                            rate =
tcp_res_data.get_result()['res_data']['rate']
-                            deviation =
tcp_res_data.get_result()['res_data']['rate_deviation']
-
-                            result_tcp.add_value('throughput', rate)
-                            result_tcp.add_value('throughput_min', rate -
deviation)
-                            result_tcp.add_value('throughput_max', rate +
deviation)
-                            result_tcp.add_value('throughput_deviation',
deviation)
-                            perf_api.save_result(result_tcp)
-
-                        if result_udp is not None and udp_res_data.get_result() is not
None and\
-                           udp_res_data.get_result()['res_data'] is not None:
-                            rate =
udp_res_data.get_result()['res_data']['rate']
-                            deviation =
udp_res_data.get_result()['res_data']['rate_deviation']
-
-                            result_udp.add_value('throughput', rate)
-                            result_udp.add_value('throughput_min', rate -
deviation)
-                            result_udp.add_value('throughput_max', rate +
deviation)
-                            result_udp.add_value('throughput_deviation',
deviation)
-                            perf_api.save_result(result_udp)
+                        netperf_result_template(result_udp, udp_res_data)
+                        perf_api.save_result(result_udp)
+
+                        srv_proc.intr()
 
         # These tests should fail
         # Ping across different VLAN
diff --git a/recipes/regression_tests/phase1/3_vlans_over_bond.py
b/recipes/regression_tests/phase1/3_vlans_over_bond.py
index 0fb6356..d96a44f 100644
--- a/recipes/regression_tests/phase1/3_vlans_over_bond.py
+++ b/recipes/regression_tests/phase1/3_vlans_over_bond.py
@@ -1,31 +1,17 @@
 import logging
 from lnst.Controller.Task import ctl
-from lnst.Controller.PerfRepoUtils import parse_id_mapping, get_id
+from lnst.Controller.PerfRepoUtils import netperf_baseline_template
+from lnst.Controller.PerfRepoUtils import netperf_result_template
 
 # ------
 # SETUP
 # ------
 
 mapping_file = ctl.get_alias("mapping_file")
-mapping = parse_id_mapping(mapping_file)
+perf_api = ctl.connect_PerfRepo(mapping_file)
 
 product_name = ctl.get_alias("product_name")
 
-tcp_ipv4_id = get_id(mapping, "tcp_ipv4_id")
-tcp_ipv6_id = get_id(mapping, "tcp_ipv6_id")
-udp_ipv4_id = get_id(mapping, "udp_ipv4_id")
-udp_ipv6_id = get_id(mapping, "udp_ipv6_id")
-
-if tcp_ipv4_id is not None or\
-   tcp_ipv6_id is not None or\
-   udp_ipv4_id is not None or\
-   udp_ipv6_id is not None:
-    perf_api = ctl.connect_PerfRepo()
-    logging.info("PerfRepo support enabled for this run.")
-else:
-    logging.info("PerfRepo support disabled for this run.")
-
-
 m1 = ctl.get_host("testmachine1")
 m2 = ctl.get_host("testmachine2")
 
@@ -147,169 +133,101 @@ for vlan1 in vlans:
                         # Ping test
                         m1.run(ping_mod)
 
-                        # prepare PerfRepo result for tcp
-                        result_tcp = None
-                        result_udp = None
-                        if tcp_ipv4_id is not None:
-                            result_tcp = perf_api.new_result(tcp_ipv4_id,
"tcp_ipv4_result")
-                            result_tcp.set_parameter(offload, state)
-                            result_tcp.set_parameter('netperf_server_on_vlan',
vlan1)
-                            result_tcp.set_parameter('netperf_client_on_vlan',
vlan2)
-                            if product_name is not None:
-                                result_tcp.set_tag(product_name)
-                            res_hash =
result_tcp.generate_hash(['kernel_release',
-                                                                
'redhat_release'])
-                            result_tcp.set_tag(res_hash)
-
-                            baseline = None
-                            report_id = get_id(mapping, res_hash)
-                            if report_id is not None:
-                                baseline = perf_api.get_baseline(report_id)
-
-                            if baseline is not None:
-                                baseline_throughput =
baseline.get_value('throughput').get_result()
-                                baseline_deviation =
baseline.get_value('throughput_deviation').get_result()
-                                netperf_cli_tcp.update_options({'threshold':
'%s bits/sec' % baseline_throughput,
-                                                               
'threshold_deviation': '%s bits/sec' % baseline_deviation})
-
-                        # prepare PerfRepo result for udp
-                        if udp_ipv4_id is not None:
-                            result_udp = perf_api.new_result(udp_ipv4_id,
"udp_ipv4_result")
-                            result_udp.set_parameter(offload, state)
-                            result_udp.set_parameter('netperf_server_on_vlan',
vlan1)
-                            result_udp.set_parameter('netperf_client_on_vlan',
vlan2)
-                            if product_name is not None:
-                                result_udp.set_tag(product_name)
-                            res_hash =
result_udp.generate_hash(['kernel_release',
-                                                                
'redhat_release'])
-                            result_udp.set_tag(res_hash)
-
-                            baseline = None
-                            report_id = get_id(mapping, res_hash)
-                            if report_id is not None:
-                                baseline = perf_api.get_baseline(report_id)
-
-                            if baseline is not None:
-                                baseline_throughput =
baseline.get_value('throughput').get_result()
-                                baseline_deviation =
baseline.get_value('throughput_deviation').get_result()
-                                netperf_cli_udp.update_options({'threshold':
'%s bits/sec' % baseline_throughput,
-                                                               
'threshold_deviation': '%s bits/sec' % baseline_deviation})
-
-
                         # Netperf test (both TCP and UDP)
                         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'])
+                        result_tcp.set_parameter(offload, state)
+                        result_tcp.set_parameter('netperf_server_on_vlan',
vlan1)
+                        result_tcp.set_parameter('netperf_client_on_vlan',
vlan2)
+                        result_tcp.add_tag(product_name)
+
+                        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)
+                        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'])
+                        result_udp.set_parameter(offload, state)
+                        result_udp.set_parameter('netperf_server_on_vlan',
vlan1)
+                        result_udp.set_parameter('netperf_client_on_vlan',
vlan2)
+                        result_udp.add_tag(product_name)
+
+                        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)
-                        srv_proc.intr()
 
-                        if result_tcp is not None and\
-                           tcp_res_data.get_result() is not None and\
-                           tcp_res_data.get_result()['res_data'] is not None:
-                            rate =
tcp_res_data.get_result()['res_data']['rate']
-                            deviation =
tcp_res_data.get_result()['res_data']['rate_deviation']
-
-                            result_tcp.add_value('throughput', rate)
-                            result_tcp.add_value('throughput_min', rate -
deviation)
-                            result_tcp.add_value('throughput_max', rate +
deviation)
-                            result_tcp.add_value('throughput_deviation',
deviation)
-                            perf_api.save_result(result_tcp)
-
-                        if result_udp is not None and udp_res_data.get_result() is not
None and\
-                           udp_res_data.get_result()['res_data'] is not None:
-                            rate =
udp_res_data.get_result()['res_data']['rate']
-                            deviation =
udp_res_data.get_result()['res_data']['rate_deviation']
-
-                            result_udp.add_value('throughput', rate)
-                            result_udp.add_value('throughput_min', rate -
deviation)
-                            result_udp.add_value('throughput_max', rate +
deviation)
-                            result_udp.add_value('throughput_deviation',
deviation)
-                            perf_api.save_result(result_udp)
+                        netperf_result_template(result_udp, udp_res_data)
+                        perf_api.save_result(result_udp)
+
+                        srv_proc.intr()
 
                     if ipv in [ 'ipv6', 'both' ]:
                         # Ping test
                         m1.run(ping_mod6)
 
-                        # prepare PerfRepo result for tcp ipv6
-                        result_tcp = None
-                        result_udp = None
-                        if tcp_ipv6_id is not None:
-                            result_tcp = perf_api.new_result(tcp_ipv6_id,
"tcp_ipv6_result")
-                            result_tcp.set_parameter(offload, state)
-                            result_tcp.set_parameter('netperf_server_on_vlan',
vlan1)
-                            result_tcp.set_parameter('netperf_client_on_vlan',
vlan2)
-                            if product_name is not None:
-                                result_tcp.set_tag(product_name)
-                            res_hash =
result_tcp.generate_hash(['kernel_release',
-                                                                
'redhat_release'])
-                            result_tcp.set_tag(res_hash)
-
-                            baseline = None
-                            report_id = get_id(mapping, res_hash)
-                            if report_id is not None:
-                                baseline = perf_api.get_baseline(report_id)
-
-                            if baseline is not None:
-                                baseline_throughput =
baseline.get_value('throughput').get_result()
-                                baseline_deviation =
baseline.get_value('throughput_deviation').get_result()
-                                netperf_cli_tcp.update_options({'threshold':
'%s bits/sec' % baseline_throughput,
-                                                               
'threshold_deviation': '%s bits/sec' % baseline_deviation})
-
-                        # prepare PerfRepo result for udp ipv6
-                        if udp_ipv6_id is not None:
-                            result_udp = perf_api.new_result(udp_ipv6_id,
"udp_ipv6_result")
-                            result_udp.set_parameter(offload, state)
-                            result_udp.set_parameter('netperf_server_on_vlan',
vlan1)
-                            result_udp.set_parameter('netperf_client_on_vlan',
vlan2)
-                            if product_name is not None:
-                                result_udp.set_tag(product_name)
-                            res_hash =
result_udp.generate_hash(['kernel_release',
-                                                                
'redhat_release'])
-                            result_udp.set_tag(res_hash)
-
-                            baseline = None
-                            report_id = get_id(mapping, res_hash)
-                            if report_id is not None:
-                                baseline = perf_api.get_baseline(report_id)
-
-                            if baseline is not None:
-                                baseline_throughput =
baseline.get_value('throughput').get_result()
-                                baseline_deviation =
baseline.get_value('throughput_deviation').get_result()
-                                netperf_cli_udp.update_options({'threshold':
'%s bits/sec' % baseline_throughput,
-                                                               
'threshold_deviation': '%s bits/sec' % baseline_deviation})
-
                         # Netperf test (both TCP and UDP)
                         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'])
+                        result_tcp.set_parameter(offload, state)
+                        result_tcp.set_parameter('netperf_server_on_vlan',
vlan1)
+                        result_tcp.set_parameter('netperf_client_on_vlan',
vlan2)
+                        result_tcp.add_tag(product_name)
+
+                        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)
+                        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'])
+                        result_udp.set_parameter(offload, state)
+                        result_udp.set_parameter('netperf_server_on_vlan',
vlan1)
+                        result_udp.set_parameter('netperf_client_on_vlan',
vlan2)
+                        result_udp.add_tag(product_name)
+
+                        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)
-                        srv_proc.intr()
 
-                        if result_tcp is not None and tcp_res_data.get_result() is not
None and\
-                           tcp_res_data.get_result()['res_data'] is not None:
-                            rate =
tcp_res_data.get_result()['res_data']['rate']
-                            deviation =
tcp_res_data.get_result()['res_data']['rate_deviation']
-
-                            result_tcp.add_value('throughput', rate)
-                            result_tcp.add_value('throughput_min', rate -
deviation)
-                            result_tcp.add_value('throughput_max', rate +
deviation)
-                            result_tcp.add_value('throughput_deviation',
deviation)
-                            perf_api.save_result(result_tcp)
-
-                        if result_udp is not None and udp_res_data.get_result() is not
None and\
-                           udp_res_data.get_result()['res_data'] is not None:
-                            rate =
udp_res_data.get_result()['res_data']['rate']
-                            deviation =
udp_res_data.get_result()['res_data']['rate_deviation']
-
-                            result_udp.add_value('throughput', rate)
-                            result_udp.add_value('throughput_min', rate -
deviation)
-                            result_udp.add_value('throughput_max', rate +
deviation)
-                            result_udp.add_value('throughput_deviation',
deviation)
-                            perf_api.save_result(result_udp)
+                        netperf_result_template(result_udp, udp_res_data)
+                        perf_api.save_result(result_udp)
+
+                        srv_proc.intr()
 
         # These tests should fail
         # Ping across different VLAN
diff --git a/recipes/regression_tests/phase1/bonding_test.py
b/recipes/regression_tests/phase1/bonding_test.py
index 2e2e041..4d4a733 100644
--- a/recipes/regression_tests/phase1/bonding_test.py
+++ b/recipes/regression_tests/phase1/bonding_test.py
@@ -1,30 +1,17 @@
 import logging
 from lnst.Controller.Task import ctl
-from lnst.Controller.PerfRepoUtils import parse_id_mapping, get_id
+from lnst.Controller.PerfRepoUtils import netperf_baseline_template
+from lnst.Controller.PerfRepoUtils import netperf_result_template
 
 # ------
 # SETUP
 # ------
 
 mapping_file = ctl.get_alias("mapping_file")
-mapping = parse_id_mapping(mapping_file)
+perf_api = ctl.connect_PerfRepo(mapping_file)
 
 product_name = ctl.get_alias("product_name")
 
-tcp_ipv4_id = get_id(mapping, "tcp_ipv4_id")
-tcp_ipv6_id = get_id(mapping, "tcp_ipv6_id")
-udp_ipv4_id = get_id(mapping, "udp_ipv4_id")
-udp_ipv6_id = get_id(mapping, "udp_ipv6_id")
-
-if tcp_ipv4_id is not None or\
-   tcp_ipv6_id is not None or\
-   udp_ipv4_id is not None or\
-   udp_ipv6_id is not None:
-    perf_api = ctl.connect_PerfRepo()
-    logging.info("PerfRepo support enabled for this run.")
-else:
-    logging.info("PerfRepo support disabled for this run.")
-
 m1 = ctl.get_host("testmachine1")
 m2 = ctl.get_host("testmachine2")
 
@@ -133,153 +120,87 @@ for offload in offloads:
         if ipv in [ 'ipv4', 'both' ]:
             m1.run(ping_mod)
 
-            # prepare PerfRepo result for tcp
-            result_tcp = None
-            result_udp = None
-            if tcp_ipv4_id is not None:
-                result_tcp = perf_api.new_result(tcp_ipv4_id,
"tcp_ipv4_result")
-                result_tcp.set_parameter(offload, state)
-                if product_name is not None:
-                    result_tcp.set_tag(product_name)
-                res_hash = result_tcp.generate_hash(['kernel_release',
-                                                     'redhat_release'])
-                result_tcp.set_tag(res_hash)
-
-                baseline = None
-                report_id = get_id(mapping, res_hash)
-                if report_id is not None:
-                    baseline = perf_api.get_baseline(report_id)
-
-                if baseline is not None:
-                    baseline_throughput =
baseline.get_value('throughput').get_result()
-                    baseline_deviation =
baseline.get_value('throughput_deviation').get_result()
-                    netperf_cli_tcp.update_options({'threshold': '%s
bits/sec' % baseline_throughput,
-                                                    'threshold_deviation':
'%s bits/sec' % baseline_deviation})
-            # prepare PerfRepo result for udp
-            if udp_ipv4_id is not None:
-                result_udp = perf_api.new_result(udp_ipv4_id,
"udp_ipv4_result")
-                result_udp.set_parameter(offload, state)
-                if product_name is not None:
-                    result_udp.set_tag(product_name)
-                res_hash = result_udp.generate_hash(['kernel_release',
-                                                     'redhat_release'])
-                result_udp.set_tag(res_hash)
-
-                baseline = None
-                report_id = get_id(mapping, res_hash)
-                if report_id is not None:
-                    baseline = perf_api.get_baseline(report_id)
-
-                if baseline is not None:
-                    baseline_throughput =
baseline.get_value('throughput').get_result()
-                    baseline_deviation =
baseline.get_value('throughput_deviation').get_result()
-                    netperf_cli_udp.update_options({'threshold': '%s
bits/sec' % baseline_throughput,
-                                                    'threshold_deviation':
'%s bits/sec' % baseline_deviation})
-
             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'])
+            result_tcp.set_parameter(offload, state)
+            result_tcp.add_tag(product_name)
+
+            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)
+            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'])
+            result_udp.set_parameter(offload, state)
+            result_udp.add_tag(product_name)
+
+            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)
-            server_proc.intr()
 
-            if result_tcp is not None and\
-               tcp_res_data.get_result() is not None and\
-               tcp_res_data.get_result()['res_data'] is not None:
-                rate = tcp_res_data.get_result()['res_data']['rate']
-                deviation =
tcp_res_data.get_result()['res_data']['rate_deviation']
-
-                result_tcp.add_value('throughput', rate)
-                result_tcp.add_value('throughput_min', rate - deviation)
-                result_tcp.add_value('throughput_max', rate + deviation)
-                result_tcp.add_value('throughput_deviation', deviation)
-                perf_api.save_result(result_tcp)
-
-            if result_udp is not None and udp_res_data.get_result() is not None and\
-               udp_res_data.get_result()['res_data'] is not None:
-                rate = udp_res_data.get_result()['res_data']['rate']
-                deviation =
udp_res_data.get_result()['res_data']['rate_deviation']
-
-                result_udp.add_value('throughput', rate)
-                result_udp.add_value('throughput_min', rate - deviation)
-                result_udp.add_value('throughput_max', rate + deviation)
-                result_udp.add_value('throughput_deviation', deviation)
-                perf_api.save_result(result_udp)
+            netperf_result_template(result_udp, udp_res_data)
+            perf_api.save_result(result_udp)
+
+            server_proc.intr()
 
         if ipv in [ 'ipv6', 'both' ]:
             m1.run(ping_mod6)
 
+            server_proc = m1.run(netperf_srv6, bg=True)
+            ctl.wait(2)
+
             # prepare PerfRepo result for tcp ipv6
-            result_tcp = None
-            result_udp = None
-            if tcp_ipv6_id is not None:
-                result_tcp = perf_api.new_result(tcp_ipv6_id,
"tcp_ipv6_result")
-                result_tcp.set_parameter(offload, state)
-                if product_name is not None:
-                    result_tcp.set_tag(product_name)
-                res_hash = result_tcp.generate_hash(['kernel_release',
-                                                     'redhat_release'])
-                result_tcp.set_tag(res_hash)
-
-                baseline = None
-                report_id = get_id(mapping, res_hash)
-                if report_id is not None:
-                    baseline = perf_api.get_baseline(report_id)
-
-                if baseline is not None:
-                    baseline_throughput =
baseline.get_value('throughput').get_result()
-                    baseline_deviation =
baseline.get_value('throughput_deviation').get_result()
-                    netperf_cli_tcp.update_options({'threshold': '%s
bits/sec' % baseline_throughput,
-                                                    'threshold_deviation':
'%s bits/sec' % baseline_deviation})
+            result_tcp = perf_api.new_result("tcp_ipv6_id",
+                                             "tcp_ipv6_result"
+                                             hash_ignore=[
+                                                 'kernel_release',
+                                                 'redhat_release'])
+            result_tcp.set_parameter(offload, state)
+            result_tcp.add_tag(product_name)
 
-            # prepare PerfRepo result for udp ipv6
-            if udp_ipv6_id is not None:
-                result_udp = perf_api.new_result(udp_ipv6_id,
"udp_ipv6_result")
-                result_udp.set_parameter(offload, state)
-                if product_name is not None:
-                    result_udp.set_tag(product_name)
-                res_hash = result_udp.generate_hash(['kernel_release',
-                                                     'redhat_release'])
-                result_udp.set_tag(res_hash)
-
-                baseline = None
-                report_id = get_id(mapping, res_hash)
-                if report_id is not None:
-                    baseline = perf_api.get_baseline(report_id)
-
-                if baseline is not None:
-                    baseline_throughput =
baseline.get_value('throughput').get_result()
-                    baseline_deviation =
baseline.get_value('throughput_deviation').get_result()
-                    netperf_cli_udp.update_options({'threshold': '%s
bits/sec' % baseline_throughput,
-                                                    'threshold_deviation':
'%s bits/sec' % baseline_deviation})
+            baseline = perf_api.get_baseline_of_result(result_tcp)
+            netperf_baseline_template(netperf_cli_tcp6, baseline)
 
-            server_proc = m1.run(netperf_srv6, bg=True)
-            ctl.wait(2)
             tcp_res_data = m2.run(netperf_cli_tcp6,
                                   timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+            netperf_result_template(result_tcp, tcp_res_data)
+            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'])
+            result_udp.set_parameter(offload, state)
+            result_udp.add_tag(product_name)
+
+            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)
-            server_proc.intr()
 
-            if result_tcp is not None and tcp_res_data.get_result() is not None and\
-               tcp_res_data.get_result()['res_data'] is not None:
-                rate = tcp_res_data.get_result()['res_data']['rate']
-                deviation =
tcp_res_data.get_result()['res_data']['rate_deviation']
-
-                result_tcp.add_value('throughput', rate)
-                result_tcp.add_value('throughput_min', rate - deviation)
-                result_tcp.add_value('throughput_max', rate + deviation)
-                result_tcp.add_value('throughput_deviation', deviation)
-                perf_api.save_result(result_tcp)
-
-            if result_udp is not None and udp_res_data.get_result() is not None and\
-               udp_res_data.get_result()['res_data'] is not None:
-                rate = udp_res_data.get_result()['res_data']['rate']
-                deviation =
udp_res_data.get_result()['res_data']['rate_deviation']
-
-                result_udp.add_value('throughput', rate)
-                result_udp.add_value('throughput_min', rate - deviation)
-                result_udp.add_value('throughput_max', rate + deviation)
-                result_udp.add_value('throughput_deviation', deviation)
-                perf_api.save_result(result_udp)
+            netperf_result_template(result_udp, udp_res_data)
+            perf_api.save_result(result_udp)
+
+            server_proc.intr()
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 d96eaec..5b0cb2b 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
@@ -1,30 +1,17 @@
 import logging
 from lnst.Controller.Task import ctl
-from lnst.Controller.PerfRepoUtils import parse_id_mapping, get_id
+from lnst.Controller.PerfRepoUtils import netperf_baseline_template
+from lnst.Controller.PerfRepoUtils import netperf_result_template
 
 # ------
 # SETUP
 # ------
 
 mapping_file = ctl.get_alias("mapping_file")
-mapping = parse_id_mapping(mapping_file)
+perf_api = ctl.connect_PerfRepo(mapping_file)
 
 product_name = ctl.get_alias("product_name")
 
-tcp_ipv4_id = get_id(mapping, "tcp_ipv4_id")
-tcp_ipv6_id = get_id(mapping, "tcp_ipv6_id")
-udp_ipv4_id = get_id(mapping, "udp_ipv4_id")
-udp_ipv6_id = get_id(mapping, "udp_ipv6_id")
-
-if tcp_ipv4_id is not None or\
-   tcp_ipv6_id is not None or\
-   udp_ipv4_id is not None or\
-   udp_ipv6_id is not None:
-    perf_api = ctl.connect_PerfRepo()
-    logging.info("PerfRepo support enabled for this run.")
-else:
-    logging.info("PerfRepo support disabled for this run.")
-
 # Host 1 + guests 1 and 2
 h1 = ctl.get_host("host1")
 g1 = ctl.get_host("guest1")
@@ -224,168 +211,96 @@ for offload in offloads:
             g1.run(ping_mod_bad, expect="fail")
             g3.run(ping_mod_bad2, expect="fail")
 
+            server_proc = g1.run(netperf_srv, bg=True)
+            ctl.wait(2)
+
             # prepare PerfRepo result for tcp
-            result_tcp = None
-            result_udp = None
-            if tcp_ipv4_id is not None:
-                result_tcp = perf_api.new_result(tcp_ipv4_id,
"tcp_ipv4_result")
-                result_tcp.set_parameter(offload, state)
-                if product_name is not None:
-                    result_tcp.set_tag(product_name)
-                res_hash = result_tcp.generate_hash(['kernel_release',
+            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'])
+            result_tcp.set_parameter(offload, state)
+            result_tcp.add_tag(product_name)
+
+            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)
+            perf_api.save_result(result_tcp)
+
+            if enable_udp_perf is not None:
+                # 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'])
-                result_tcp.set_tag(res_hash)
-
-                baseline = None
-                report_id = get_id(mapping, res_hash)
-                if report_id is not None:
-                    baseline = perf_api.get_baseline(report_id)
-
-                if baseline is not None:
-                    baseline_throughput =
baseline.get_value('throughput').get_result()
-                    baseline_deviation =
baseline.get_value('throughput_deviation').get_result()
-                    netperf_cli_tcp.update_options({'threshold': '%s
bits/sec' % baseline_throughput,
-                                                    'threshold_deviation':
'%s bits/sec' % baseline_deviation})
-            # prepare PerfRepo result for udp
-            if enable_udp_perf is not None and udp_ipv4_id is not None:
-                result_udp = perf_api.new_result(udp_ipv4_id,
"udp_ipv4_result")
                 result_udp.set_parameter(offload, state)
-                if product_name is not None:
-                    result_udp.set_tag(product_name)
-                res_hash = result_udp.generate_hash(['kernel_release',
-                                                     'redhat_release',
-                                                     r'guest\d+\.hostname',
-                                                     r'guest\d+\..*hwaddr'])
-                result_udp.set_tag(res_hash)
+                result_udp.add_tag(product_name)
 
-                baseline = None
-                report_id = get_id(mapping, res_hash)
-                if report_id is not None:
-                    baseline = perf_api.get_baseline(report_id)
+                baseline = perf_api.get_baseline_of_result(result_udp)
+                netperf_baseline_template(netperf_cli_udp, baseline)
 
-                if baseline is not None:
-                    baseline_throughput =
baseline.get_value('throughput').get_result()
-                    baseline_deviation =
baseline.get_value('throughput_deviation').get_result()
-                    netperf_cli_udp.update_options({'threshold': '%s
bits/sec' % baseline_throughput,
-                                                    'threshold_deviation':
'%s bits/sec' % baseline_deviation})
-
-            server_proc = g1.run(netperf_srv, bg=True)
-            ctl.wait(2)
-            tcp_res_data = g3.run(netperf_cli_tcp,
-                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-            if enable_udp_perf is not None:
                 udp_res_data = g3.run(netperf_cli_udp,
                                       timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-            server_proc.intr()
 
-            if result_tcp is not None and\
-               tcp_res_data.get_result() is not None and\
-               tcp_res_data.get_result()['res_data'] is not None:
-                rate = tcp_res_data.get_result()['res_data']['rate']
-                deviation =
tcp_res_data.get_result()['res_data']['rate_deviation']
-
-                result_tcp.add_value('throughput', rate)
-                result_tcp.add_value('throughput_min', rate - deviation)
-                result_tcp.add_value('throughput_max', rate + deviation)
-                result_tcp.add_value('throughput_deviation', deviation)
-                perf_api.save_result(result_tcp)
-
-            if enable_udp_perf is not None and result_udp is not None and\
-               udp_res_data.get_result() is not None and\
-               udp_res_data.get_result()['res_data'] is not None:
-                rate = udp_res_data.get_result()['res_data']['rate']
-                deviation =
udp_res_data.get_result()['res_data']['rate_deviation']
-
-                result_udp.add_value('throughput', rate)
-                result_udp.add_value('throughput_min', rate - deviation)
-                result_udp.add_value('throughput_max', rate + deviation)
-                result_udp.add_value('throughput_deviation', deviation)
+                netperf_result_template(result_udp, udp_res_data)
                 perf_api.save_result(result_udp)
 
+            server_proc.intr()
+
         if ipv in [ 'ipv6', 'both' ]:
             g1.run(ping_mod6)
             g4.run(ping_mod62)
             g1.run(ping_mod6_bad, expect="fail")
             g3.run(ping_mod6_bad2, expect="fail")
 
+            server_proc = g1.run(netperf_srv6, bg=True)
+            ctl.wait(2)
+
             # prepare PerfRepo result for tcp ipv6
-            result_tcp = None
-            result_udp = None
-            if tcp_ipv6_id is not None:
-                result_tcp = perf_api.new_result(tcp_ipv6_id,
"tcp_ipv6_result")
-                result_tcp.set_parameter(offload, state)
-                if product_name is not None:
-                    result_tcp.set_tag(product_name)
-                res_hash = result_tcp.generate_hash(['kernel_release',
-                                                     'redhat_release',
-                                                     r'guest\d+\.hostname',
-                                                     r'guest\d+\..*hwaddr'])
-                result_tcp.set_tag(res_hash)
+            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'])
+            result_tcp.set_parameter(offload, state)
+            result_tcp.add_tag(product_name)
+
+            baseline = perf_api.get_baseline_of_result(result_tcp)
+            netperf_baseline_template(netperf_cli_tcp6, baseline)
 
-                baseline = None
-                report_id = get_id(mapping, res_hash)
-                if report_id is not None:
-                    baseline = perf_api.get_baseline(report_id)
+            tcp_res_data = g3.run(netperf_cli_tcp6,
+                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
 
-                if baseline is not None:
-                    baseline_throughput =
baseline.get_value('throughput').get_result()
-                    baseline_deviation =
baseline.get_value('throughput_deviation').get_result()
-                    netperf_cli_tcp.update_options({'threshold': '%s
bits/sec' % baseline_throughput,
-                                                    'threshold_deviation':
'%s bits/sec' % baseline_deviation})
+            netperf_result_template(result_tcp, tcp_res_data)
+            perf_api.save_result(result_tcp)
 
             # prepare PerfRepo result for udp ipv6
-            if enable_udp_perf is not None and udp_ipv6_id is not None:
-                result_udp = perf_api.new_result(udp_ipv6_id,
"udp_ipv6_result")
-                result_udp.set_parameter(offload, state)
-                if product_name is not None:
-                    result_udp.set_tag(product_name)
-                res_hash = result_udp.generate_hash(['kernel_release',
+            if enable_udp_perf is not None:
+                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'])
-                result_udp.set_tag(res_hash)
-
-                baseline = None
-                report_id = get_id(mapping, res_hash)
-                if report_id is not None:
-                    baseline = perf_api.get_baseline(report_id)
+                result_udp.set_parameter(offload, state)
+                result_udp.add_tag(product_name)
 
-                if baseline is not None:
-                    baseline_throughput =
baseline.get_value('throughput').get_result()
-                    baseline_deviation =
baseline.get_value('throughput_deviation').get_result()
-                    netperf_cli_udp.update_options({'threshold': '%s
bits/sec' % baseline_throughput,
-                                                    'threshold_deviation':
'%s bits/sec' % baseline_deviation})
+                baseline = perf_api.get_baseline_of_result(result_udp)
+                netperf_baseline_template(netperf_cli_udp6, baseline)
 
-            server_proc = g1.run(netperf_srv6, bg=True)
-            ctl.wait(2)
-            tcp_res_data = g3.run(netperf_cli_tcp6,
-                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-            if enable_udp_perf is not None:
                 udp_res_data = g3.run(netperf_cli_udp6,
                                       timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-            server_proc.intr()
 
-            if result_tcp is not None and tcp_res_data.get_result() is not None and\
-               tcp_res_data.get_result()['res_data'] is not None:
-                rate = tcp_res_data.get_result()['res_data']['rate']
-                deviation =
tcp_res_data.get_result()['res_data']['rate_deviation']
-
-                result_tcp.add_value('throughput', rate)
-                result_tcp.add_value('throughput_min', rate - deviation)
-                result_tcp.add_value('throughput_max', rate + deviation)
-                result_tcp.add_value('throughput_deviation', deviation)
-                perf_api.save_result(result_tcp)
-
-            if enable_udp_perf is not None and result_udp is not None and\
-               udp_res_data.get_result() is not None and\
-               udp_res_data.get_result()['res_data'] is not None:
-                rate = udp_res_data.get_result()['res_data']['rate']
-                deviation =
udp_res_data.get_result()['res_data']['rate_deviation']
-
-                result_udp.add_value('throughput', rate)
-                result_udp.add_value('throughput_min', rate - deviation)
-                result_udp.add_value('throughput_max', rate + deviation)
-                result_udp.add_value('throughput_deviation', deviation)
+                netperf_result_template(result_udp, udp_res_data)
                 perf_api.save_result(result_udp)
+
+            server_proc.intr()
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 daba9f0..9b81c83 100644
--- a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py
+++ b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py
@@ -1,30 +1,17 @@
 import logging
 from lnst.Controller.Task import ctl
-from lnst.Controller.PerfRepoUtils import parse_id_mapping, get_id
+from lnst.Controller.PerfRepoUtils import netperf_baseline_template
+from lnst.Controller.PerfRepoUtils import netperf_result_template
 
 # ------
 # SETUP
 # ------
 
 mapping_file = ctl.get_alias("mapping_file")
-mapping = parse_id_mapping(mapping_file)
+perf_api = ctl.connect_PerfRepo(mapping_file)
 
 product_name = ctl.get_alias("product_name")
 
-tcp_ipv4_id = get_id(mapping, "tcp_ipv4_id")
-tcp_ipv6_id = get_id(mapping, "tcp_ipv6_id")
-udp_ipv4_id = get_id(mapping, "udp_ipv4_id")
-udp_ipv6_id = get_id(mapping, "udp_ipv6_id")
-
-if tcp_ipv4_id is not None or\
-   tcp_ipv6_id is not None or\
-   udp_ipv4_id is not None or\
-   udp_ipv6_id is not None:
-    perf_api = ctl.connect_PerfRepo()
-    logging.info("PerfRepo support enabled for this run.")
-else:
-    logging.info("PerfRepo support disabled for this run.")
-
 h1 = ctl.get_host("host1")
 g1 = ctl.get_host("guest1")
 
@@ -147,166 +134,93 @@ for offload in offloads:
         if ipv in [ 'ipv4', 'both' ]:
             g1.run(ping_mod)
 
+            server_proc = g1.run(netperf_srv, bg=True)
+            ctl.wait(2)
+
             # prepare PerfRepo result for tcp
-            result_tcp = None
-            result_udp = None
-            if tcp_ipv4_id is not None:
-                result_tcp = perf_api.new_result(tcp_ipv4_id,
"tcp_ipv4_result")
-                result_tcp.set_parameter(offload, state)
-                if product_name is not None:
-                    result_tcp.set_tag(product_name)
-                res_hash = result_tcp.generate_hash(['kernel_release',
-                                                     'redhat_release',
-                                                     r'guest\d+\.hostname',
-                                                     r'guest\d+\..*hwaddr'])
-                result_tcp.set_tag(res_hash)
-
-                baseline = None
-                report_id = get_id(mapping, res_hash)
-                if report_id is not None:
-                    baseline = perf_api.get_baseline(report_id)
-
-                if baseline is not None:
-                    baseline_throughput =
baseline.get_value('throughput').get_result()
-                    baseline_deviation =
baseline.get_value('throughput_deviation').get_result()
-                    netperf_cli_tcp.update_options({'threshold': '%s
bits/sec' % baseline_throughput,
-                                                    'threshold_deviation':
'%s bits/sec' % baseline_deviation})
+            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'])
+            result_tcp.set_parameter(offload, state)
+            result_tcp.add_tag(product_name)
+
+            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)
+            perf_api.save_result(result_tcp)
+
             # prepare PerfRepo result for udp
-            if enable_udp_perf is not None and udp_ipv4_id is not None:
-                result_udp = perf_api.new_result(udp_ipv4_id,
"udp_ipv4_result")
-                result_udp.set_parameter(offload, state)
-                if product_name is not None:
-                    result_udp.set_tag(product_name)
-                res_hash = result_udp.generate_hash(['kernel_release',
+            if enable_udp_perf is not None:
+                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'])
-                result_udp.set_tag(res_hash)
-
-                baseline = None
-                report_id = get_id(mapping, res_hash)
-                if report_id is not None:
-                    baseline = perf_api.get_baseline(report_id)
+                result_udp.set_parameter(offload, state)
+                result_udp.add_tag(product_name)
 
-                if baseline is not None:
-                    baseline_throughput =
baseline.get_value('throughput').get_result()
-                    baseline_deviation =
baseline.get_value('throughput_deviation').get_result()
-                    netperf_cli_udp.update_options({'threshold': '%s
bits/sec' % baseline_throughput,
-                                                    'threshold_deviation':
'%s bits/sec' % baseline_deviation})
+                baseline = perf_api.get_baseline_of_result(result_udp)
+                netperf_baseline_template(netperf_cli_udp, baseline)
 
-            server_proc = g1.run(netperf_srv, bg=True)
-            ctl.wait(2)
-            tcp_res_data = h2.run(netperf_cli_tcp,
-                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-            if enable_udp_perf is not None:
                 udp_res_data = h2.run(netperf_cli_udp,
                                       timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
 
-            server_proc.intr()
-
-            if result_tcp is not None and\
-               tcp_res_data.get_result() is not None and\
-               tcp_res_data.get_result()['res_data'] is not None:
-                rate = tcp_res_data.get_result()['res_data']['rate']
-                deviation =
tcp_res_data.get_result()['res_data']['rate_deviation']
-
-                result_tcp.add_value('throughput', rate)
-                result_tcp.add_value('throughput_min', rate - deviation)
-                result_tcp.add_value('throughput_max', rate + deviation)
-                result_tcp.add_value('throughput_deviation', deviation)
-                perf_api.save_result(result_tcp)
-
-            if enable_udp_perf is not None and result_udp is not None and\
-               udp_res_data.get_result() is not None and\
-               udp_res_data.get_result()['res_data'] is not None:
-                rate = udp_res_data.get_result()['res_data']['rate']
-                deviation =
udp_res_data.get_result()['res_data']['rate_deviation']
-
-                result_udp.add_value('throughput', rate)
-                result_udp.add_value('throughput_min', rate - deviation)
-                result_udp.add_value('throughput_max', rate + deviation)
-                result_udp.add_value('throughput_deviation', deviation)
+                netperf_result_template(result_udp, udp_res_data)
                 perf_api.save_result(result_udp)
 
+            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 = None
-            result_udp = None
-            if tcp_ipv6_id is not None:
-                result_tcp = perf_api.new_result(tcp_ipv6_id,
"tcp_ipv6_result")
-                result_tcp.set_parameter(offload, state)
-                if product_name is not None:
-                    result_tcp.set_tag(product_name)
-                res_hash = result_tcp.generate_hash(['kernel_release',
-                                                     'redhat_release',
-                                                     r'guest\d+\.hostname',
-                                                     r'guest\d+\..*hwaddr'])
-                result_tcp.set_tag(res_hash)
+            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'])
+            result_tcp.set_parameter(offload, state)
+            result_tcp.add_tag(product_name)
+
+            baseline = perf_api.get_baseline_of_result(result_tcp)
+            netperf_baseline_template(netperf_cli_tcp6, baseline)
 
-                baseline = None
-                report_id = get_id(mapping, res_hash)
-                if report_id is not None:
-                    baseline = perf_api.get_baseline(report_id)
+            tcp_res_data = h2.run(netperf_cli_tcp6,
+                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
 
-                if baseline is not None:
-                    baseline_throughput =
baseline.get_value('throughput').get_result()
-                    baseline_deviation =
baseline.get_value('throughput_deviation').get_result()
-                    netperf_cli_tcp.update_options({'threshold': '%s
bits/sec' % baseline_throughput,
-                                                    'threshold_deviation':
'%s bits/sec' % baseline_deviation})
+            netperf_result_template(result_tcp, tcp_res_data)
+            perf_api.save_result(result_tcp)
 
             # prepare PerfRepo result for udp ipv6
-            if enable_udp_perf is not None and udp_ipv6_id is not None:
-                result_udp = perf_api.new_result(udp_ipv6_id,
"udp_ipv6_result")
-                result_udp.set_parameter(offload, state)
-                if product_name is not None:
-                    result_udp.set_tag(product_name)
-                res_hash = result_udp.generate_hash(['kernel_release',
+            if enable_udp_perf is not None:
+                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'])
-                result_udp.set_tag(res_hash)
+                result_udp.set_parameter(offload, state)
+                result_udp.add_tag(product_name)
 
-                baseline = None
-                report_id = get_id(mapping, res_hash)
-                if report_id is not None:
-                    baseline = perf_api.get_baseline(report_id)
+                baseline = perf_api.get_baseline_of_result(result_tcp)
+                netperf_baseline_template(netperf_cli_udp6, baseline)
 
-                if baseline is not None:
-                    baseline_throughput =
baseline.get_value('throughput').get_result()
-                    baseline_deviation =
baseline.get_value('throughput_deviation').get_result()
-                    netperf_cli_udp.update_options({'threshold': '%s
bits/sec' % baseline_throughput,
-                                                    'threshold_deviation':
'%s bits/sec' % baseline_deviation})
+                udp_res_data = h2.run(netperf_cli_udp6,
+                                      timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
 
-            server_proc = g1.run(netperf_srv6, bg=True)
-            ctl.wait(2)
-            tcp_res_data = h2.run(netperf_cli_tcp6,
-                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-            udp_res_data = h2.run(netperf_cli_udp6,
-                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+                netperf_result_template(result_udp, udp_res_data)
+                perf_api.save_result(result_udp)
 
             server_proc.intr()
-
-            if result_tcp is not None and tcp_res_data.get_result() is not None and\
-               tcp_res_data.get_result()['res_data'] is not None:
-                rate = tcp_res_data.get_result()['res_data']['rate']
-                deviation =
tcp_res_data.get_result()['res_data']['rate_deviation']
-
-                result_tcp.add_value('throughput', rate)
-                result_tcp.add_value('throughput_min', rate - deviation)
-                result_tcp.add_value('throughput_max', rate + deviation)
-                result_tcp.add_value('throughput_deviation', deviation)
-                perf_api.save_result(result_tcp)
-
-            if enable_udp_perf is not None and result_udp is not None and\
-               udp_res_data.get_result() is not None and\
-               udp_res_data.get_result()['res_data'] is not None:
-                rate = udp_res_data.get_result()['res_data']['rate']
-                deviation =
udp_res_data.get_result()['res_data']['rate_deviation']
-
-                result_udp.add_value('throughput', rate)
-                result_udp.add_value('throughput_min', rate - deviation)
-                result_udp.add_value('throughput_max', rate + deviation)
-                result_udp.add_value('throughput_deviation', deviation)
-                perf_api.save_result(result_udp)
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 10d0696..10ce9a8 100644
--- a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py
+++ b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py
@@ -1,30 +1,17 @@
 import logging
 from lnst.Controller.Task import ctl
-from lnst.Controller.PerfRepoUtils import parse_id_mapping, get_id
+from lnst.Controller.PerfRepoUtils import netperf_baseline_template
+from lnst.Controller.PerfRepoUtils import netperf_result_template
 
 # ------
 # SETUP
 # ------
 
 mapping_file = ctl.get_alias("mapping_file")
-mapping = parse_id_mapping(mapping_file)
+perf_api = ctl.connect_PerfRepo(mapping_file)
 
 product_name = ctl.get_alias("product_name")
 
-tcp_ipv4_id = get_id(mapping, "tcp_ipv4_id")
-tcp_ipv6_id = get_id(mapping, "tcp_ipv6_id")
-udp_ipv4_id = get_id(mapping, "udp_ipv4_id")
-udp_ipv6_id = get_id(mapping, "udp_ipv6_id")
-
-if tcp_ipv4_id is not None or\
-   tcp_ipv6_id is not None or\
-   udp_ipv4_id is not None or\
-   udp_ipv6_id is not None:
-    perf_api = ctl.connect_PerfRepo()
-    logging.info("PerfRepo support enabled for this run.")
-else:
-    logging.info("PerfRepo support disabled for this run.")
-
 h1 = ctl.get_host("host1")
 g1 = ctl.get_host("guest1")
 
@@ -147,166 +134,93 @@ for offload in offloads:
         if ipv in [ 'ipv4', 'both' ]:
             g1.run(ping_mod)
 
+            server_proc = g1.run(netperf_srv, bg=True)
+            ctl.wait(2)
+
             # prepare PerfRepo result for tcp
-            result_tcp = None
-            result_udp = None
-            if tcp_ipv4_id is not None:
-                result_tcp = perf_api.new_result(tcp_ipv4_id,
"tcp_ipv4_result")
-                result_tcp.set_parameter(offload, state)
-                if product_name is not None:
-                    result_tcp.set_tag(product_name)
-                res_hash = result_tcp.generate_hash(['kernel_release',
-                                                     'redhat_release',
-                                                     r'guest\d+\.hostname',
-                                                     r'guest\d+\..*hwaddr'])
-                result_tcp.set_tag(res_hash)
-
-                baseline = None
-                report_id = get_id(mapping, res_hash)
-                if report_id is not None:
-                    baseline = perf_api.get_baseline(report_id)
-
-                if baseline is not None:
-                    baseline_throughput =
baseline.get_value('throughput').get_result()
-                    baseline_deviation =
baseline.get_value('throughput_deviation').get_result()
-                    netperf_cli_tcp.update_options({'threshold': '%s
bits/sec' % baseline_throughput,
-                                                    'threshold_deviation':
'%s bits/sec' % baseline_deviation})
+            result_tcp = perf_api.new_result("tcp_ipv4_id",
+                                             "tcp_ipv4_result",
+                                             ignore_hash=['kernel_release',
+                                                 'redhat_release',
+                                                 r'guest\d+\.hostname',
+                                                 r'guest\d+\..*hwaddr'])
+            result_tcp.set_parameter(offload, state)
+            result_tcp.add_tag(product_name)
+
+            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)
+            perf_api.save_result(result_tcp)
+
             # prepare PerfRepo result for udp
-            if enable_udp_perf is not None and udp_ipv4_id is not None:
-                result_udp = perf_api.new_result(udp_ipv4_id,
"udp_ipv4_result")
-                result_udp.set_parameter(offload, state)
-                if product_name is not None:
-                    result_udp.set_tag(product_name)
-                res_hash = result_udp.generate_hash(['kernel_release',
+            if enable_udp_perf is not None:
+                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'])
-                result_udp.set_tag(res_hash)
-
-                baseline = None
-                report_id = get_id(mapping, res_hash)
-                if report_id is not None:
-                    baseline = perf_api.get_baseline(report_id)
+                result_udp.set_parameter(offload, state)
+                result_udp.add_tag(product_name)
 
-                if baseline is not None:
-                    baseline_throughput =
baseline.get_value('throughput').get_result()
-                    baseline_deviation =
baseline.get_value('throughput_deviation').get_result()
-                    netperf_cli_udp.update_options({'threshold': '%s
bits/sec' % baseline_throughput,
-                                                    'threshold_deviation':
'%s bits/sec' % baseline_deviation})
+                baseline = perf_api.get_baseline_of_result(result_udp)
+                netperf_baseline_template(netperf_cli_udp, baseline)
 
-            server_proc = g1.run(netperf_srv, bg=True)
-            ctl.wait(2)
-            tcp_res_data = h2.run(netperf_cli_tcp,
-                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-            if enable_udp_perf is not None:
                 udp_res_data = h2.run(netperf_cli_udp,
                                       timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
 
-            server_proc.intr()
-
-            if result_tcp is not None and\
-               tcp_res_data.get_result() is not None and\
-               tcp_res_data.get_result()['res_data'] is not None:
-                rate = tcp_res_data.get_result()['res_data']['rate']
-                deviation =
tcp_res_data.get_result()['res_data']['rate_deviation']
-
-                result_tcp.add_value('throughput', rate)
-                result_tcp.add_value('throughput_min', rate - deviation)
-                result_tcp.add_value('throughput_max', rate + deviation)
-                result_tcp.add_value('throughput_deviation', deviation)
-                perf_api.save_result(result_tcp)
-
-            if enable_udp_perf is not None and result_udp is not None and\
-               udp_res_data.get_result() is not None and\
-               udp_res_data.get_result()['res_data'] is not None:
-                rate = udp_res_data.get_result()['res_data']['rate']
-                deviation =
udp_res_data.get_result()['res_data']['rate_deviation']
-
-                result_udp.add_value('throughput', rate)
-                result_udp.add_value('throughput_min', rate - deviation)
-                result_udp.add_value('throughput_max', rate + deviation)
-                result_udp.add_value('throughput_deviation', deviation)
+                netperf_result_template(result_udp, udp_res_data)
                 perf_api.save_result(result_udp)
 
+            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 = None
-            result_udp = None
-            if tcp_ipv6_id is not None:
-                result_tcp = perf_api.new_result(tcp_ipv6_id,
"tcp_ipv6_result")
-                result_tcp.set_parameter(offload, state)
-                if product_name is not None:
-                    result_tcp.set_tag(product_name)
-                res_hash = result_tcp.generate_hash(['kernel_release',
-                                                     'redhat_release',
-                                                     r'guest\d+\.hostname',
-                                                     r'guest\d+\..*hwaddr'])
-                result_tcp.set_tag(res_hash)
+            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'])
+            result_tcp.set_parameter(offload, state)
+            result_tcp.add_tag(product_name)
+
+            baseline = perf_api.get_baseline_of_result(result_tcp)
+            netperf_baseline_template(netperf_cli_tcp6, baseline)
 
-                baseline = None
-                report_id = get_id(mapping, res_hash)
-                if report_id is not None:
-                    baseline = perf_api.get_baseline(report_id)
+            tcp_res_data = h2.run(netperf_cli_tcp6,
+                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
 
-                if baseline is not None:
-                    baseline_throughput =
baseline.get_value('throughput').get_result()
-                    baseline_deviation =
baseline.get_value('throughput_deviation').get_result()
-                    netperf_cli_tcp.update_options({'threshold': '%s
bits/sec' % baseline_throughput,
-                                                    'threshold_deviation':
'%s bits/sec' % baseline_deviation})
+            netperf_result_template(result_tcp, tcp_res_data)
+            perf_api.save_result(result_tcp)
 
             # prepare PerfRepo result for udp ipv6
-            if enable_udp_perf is not None and udp_ipv6_id is not None:
-                result_udp = perf_api.new_result(udp_ipv6_id,
"udp_ipv6_result")
-                result_udp.set_parameter(offload, state)
-                if product_name is not None:
-                    result_udp.set_tag(product_name)
-                res_hash = result_udp.generate_hash(['kernel_release',
+            if enable_udp_perf:
+                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'])
-                result_udp.set_tag(res_hash)
+                result_udp.set_parameter(offload, state)
+                result_udp.add_tag(product_name)
 
-                baseline = None
-                report_id = get_id(mapping, res_hash)
-                if report_id is not None:
-                    baseline = perf_api.get_baseline(report_id)
+                baseline = perf_api.get_baseline_of_result(result_udp)
+                netperf_baseline_template(netperf_cli_udp6, baseline)
 
-                if baseline is not None:
-                    baseline_throughput =
baseline.get_value('throughput').get_result()
-                    baseline_deviation =
baseline.get_value('throughput_deviation').get_result()
-                    netperf_cli_udp.update_options({'threshold': '%s
bits/sec' % baseline_throughput,
-                                                    'threshold_deviation':
'%s bits/sec' % baseline_deviation})
+                udp_res_data = h2.run(netperf_cli_udp6,
+                                      timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
 
-            server_proc = g1.run(netperf_srv6, bg=True)
-            ctl.wait(2)
-            tcp_res_data = h2.run(netperf_cli_tcp6,
-                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-            udp_res_data = h2.run(netperf_cli_udp6,
-                                  timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+                netperf_result_template(result_udp, udp_res_data)
+                perf_api.save_result(result_udp)
 
             server_proc.intr()
-
-            if result_tcp is not None and tcp_res_data.get_result() is not None and\
-               tcp_res_data.get_result()['res_data'] is not None:
-                rate = tcp_res_data.get_result()['res_data']['rate']
-                deviation =
tcp_res_data.get_result()['res_data']['rate_deviation']
-
-                result_tcp.add_value('throughput', rate)
-                result_tcp.add_value('throughput_min', rate - deviation)
-                result_tcp.add_value('throughput_max', rate + deviation)
-                result_tcp.add_value('throughput_deviation', deviation)
-                perf_api.save_result(result_tcp)
-
-            if enable_udp_perf is not None and result_udp is not None and\
-               udp_res_data.get_result() is not None and\
-               udp_res_data.get_result()['res_data'] is not None:
-                rate = udp_res_data.get_result()['res_data']['rate']
-                deviation =
udp_res_data.get_result()['res_data']['rate_deviation']
-
-                result_udp.add_value('throughput', rate)
-                result_udp.add_value('throughput_min', rate - deviation)
-                result_udp.add_value('throughput_max', rate + deviation)
-                result_udp.add_value('throughput_deviation', deviation)
-                perf_api.save_result(result_udp)
diff --git a/recipes/regression_tests/phase2/3_vlans_over_team.py
b/recipes/regression_tests/phase2/3_vlans_over_team.py
index 361f497..905674d 100644
--- a/recipes/regression_tests/phase2/3_vlans_over_team.py
+++ b/recipes/regression_tests/phase2/3_vlans_over_team.py
@@ -1,30 +1,17 @@
 import logging
 from lnst.Controller.Task import ctl
-from lnst.Controller.PerfRepoUtils import parse_id_mapping, get_id
+from lnst.Controller.PerfRepoUtils import netperf_baseline_template
+from lnst.Controller.PerfRepoUtils import netperf_result_template
 
 # ------
 # SETUP
 # ------
 
 mapping_file = ctl.get_alias("mapping_file")
-mapping = parse_id_mapping(mapping_file)
+perf_api = ctl.connect_PerfRepo(mapping_file)
 
 product_name = ctl.get_alias("product_name")
 
-tcp_ipv4_id = get_id(mapping, "tcp_ipv4_id")
-tcp_ipv6_id = get_id(mapping, "tcp_ipv6_id")
-udp_ipv4_id = get_id(mapping, "udp_ipv4_id")
-udp_ipv6_id = get_id(mapping, "udp_ipv6_id")
-
-if tcp_ipv4_id is not None or\
-   tcp_ipv6_id is not None or\
-   udp_ipv4_id is not None or\
-   udp_ipv6_id is not None:
-    perf_api = ctl.connect_PerfRepo()
-    logging.info("PerfRepo support enabled for this run.")
-else:
-    logging.info("PerfRepo support disabled for this run.")
-
 m1 = ctl.get_host("testmachine1")
 m2 = ctl.get_host("testmachine2")
 
@@ -148,168 +135,100 @@ for vlan1 in vlans:
                         # Ping test
                         m1.run(ping_mod)
 
-                        # prepare PerfRepo result for tcp
-                        result_tcp = None
-                        result_udp = None
-                        if tcp_ipv4_id is not None:
-                            result_tcp = perf_api.new_result(tcp_ipv4_id,
"tcp_ipv4_result")
-                            result_tcp.set_parameter(offload, state)
-                            result_tcp.set_parameter('netperf_server_on_vlan',
vlan1)
-                            result_tcp.set_parameter('netperf_client_on_vlan',
vlan2)
-                            if product_name is not None:
-                                result_tcp.set_tag(product_name)
-                            res_hash =
result_tcp.generate_hash(['kernel_release',
-                                                                
'redhat_release'])
-                            result_tcp.set_tag(res_hash)
-
-                            baseline = None
-                            report_id = get_id(mapping, res_hash)
-                            if report_id is not None:
-                                baseline = perf_api.get_baseline(report_id)
-
-                            if baseline is not None:
-                                baseline_throughput =
baseline.get_value('throughput').get_result()
-                                baseline_deviation =
baseline.get_value('throughput_deviation').get_result()
-                                netperf_cli_tcp.update_options({'threshold':
'%s bits/sec' % baseline_throughput,
-                                                               
'threshold_deviation': '%s bits/sec' % baseline_deviation})
-
-                        # prepare PerfRepo result for udp
-                        if udp_ipv4_id is not None:
-                            result_udp = perf_api.new_result(udp_ipv4_id,
"udp_ipv4_result")
-                            result_udp.set_parameter(offload, state)
-                            result_udp.set_parameter('netperf_server_on_vlan',
vlan1)
-                            result_udp.set_parameter('netperf_client_on_vlan',
vlan2)
-                            if product_name is not None:
-                                result_udp.set_tag(product_name)
-                            res_hash =
result_udp.generate_hash(['kernel_release',
-                                                                
'redhat_release'])
-                            result_udp.set_tag(res_hash)
-
-                            baseline = None
-                            report_id = get_id(mapping, res_hash)
-                            if report_id is not None:
-                                baseline = perf_api.get_baseline(report_id)
-
-                            if baseline is not None:
-                                baseline_throughput =
baseline.get_value('throughput').get_result()
-                                baseline_deviation =
baseline.get_value('throughput_deviation').get_result()
-                                netperf_cli_udp.update_options({'threshold':
'%s bits/sec' % baseline_throughput,
-                                                               
'threshold_deviation': '%s bits/sec' % baseline_deviation})
-
                         # Netperf test (both TCP and UDP)
                         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'])
+                        result_tcp.set_parameter(offload, state)
+                        result_tcp.set_parameter('netperf_server_on_vlan',
vlan1)
+                        result_tcp.set_parameter('netperf_client_on_vlan',
vlan2)
+                        result_tcp.add_tag(product_name)
+
+                        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)
+                        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'])
+                        result_udp.set_parameter(offload, state)
+                        result_udp.set_parameter('netperf_server_on_vlan',
vlan1)
+                        result_udp.set_parameter('netperf_client_on_vlan',
vlan2)
+                        result_udp.add_tag(product_name)
+
+                        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)
-                        srv_proc.intr()
 
-                        if result_tcp is not None and\
-                           tcp_res_data.get_result() is not None and\
-                           tcp_res_data.get_result()['res_data'] is not None:
-                            rate =
tcp_res_data.get_result()['res_data']['rate']
-                            deviation =
tcp_res_data.get_result()['res_data']['rate_deviation']
-
-                            result_tcp.add_value('throughput', rate)
-                            result_tcp.add_value('throughput_min', rate -
deviation)
-                            result_tcp.add_value('throughput_max', rate +
deviation)
-                            result_tcp.add_value('throughput_deviation',
deviation)
-                            perf_api.save_result(result_tcp)
-
-                        if result_udp is not None and udp_res_data.get_result() is not
None and\
-                           udp_res_data.get_result()['res_data'] is not None:
-                            rate =
udp_res_data.get_result()['res_data']['rate']
-                            deviation =
udp_res_data.get_result()['res_data']['rate_deviation']
-
-                            result_udp.add_value('throughput', rate)
-                            result_udp.add_value('throughput_min', rate -
deviation)
-                            result_udp.add_value('throughput_max', rate +
deviation)
-                            result_udp.add_value('throughput_deviation',
deviation)
-                            perf_api.save_result(result_udp)
+                        netperf_result_template(result_udp, udp_res_data)
+                        perf_api.save_result(result_udp)
+
+                        srv_proc.intr()
 
                     if ipv in [ 'ipv6', 'both' ]:
                         m1.run(ping_mod6)
 
-                        # prepare PerfRepo result for tcp ipv6
-                        result_tcp = None
-                        result_udp = None
-                        if tcp_ipv6_id is not None:
-                            result_tcp = perf_api.new_result(tcp_ipv6_id,
"tcp_ipv6_result")
-                            result_tcp.set_parameter(offload, state)
-                            result_tcp.set_parameter('netperf_server_on_vlan',
vlan1)
-                            result_tcp.set_parameter('netperf_client_on_vlan',
vlan2)
-                            if product_name is not None:
-                                result_tcp.set_tag(product_name)
-                            res_hash =
result_tcp.generate_hash(['kernel_release',
-                                                                
'redhat_release'])
-                            result_tcp.set_tag(res_hash)
-
-                            baseline = None
-                            report_id = get_id(mapping, res_hash)
-                            if report_id is not None:
-                                baseline = perf_api.get_baseline(report_id)
-
-                            if baseline is not None:
-                                baseline_throughput =
baseline.get_value('throughput').get_result()
-                                baseline_deviation =
baseline.get_value('throughput_deviation').get_result()
-                                netperf_cli_tcp.update_options({'threshold':
'%s bits/sec' % baseline_throughput,
-                                                               
'threshold_deviation': '%s bits/sec' % baseline_deviation})
-
-                        # prepare PerfRepo result for udp ipv6
-                        if udp_ipv6_id is not None:
-                            result_udp = perf_api.new_result(udp_ipv6_id,
"udp_ipv6_result")
-                            result_udp.set_parameter(offload, state)
-                            result_udp.set_parameter('netperf_server_on_vlan',
vlan1)
-                            result_udp.set_parameter('netperf_client_on_vlan',
vlan2)
-                            if product_name is not None:
-                                result_udp.set_tag(product_name)
-                            res_hash =
result_udp.generate_hash(['kernel_release',
-                                                                
'redhat_release'])
-                            result_udp.set_tag(res_hash)
-
-                            baseline = None
-                            report_id = get_id(mapping, res_hash)
-                            if report_id is not None:
-                                baseline = perf_api.get_baseline(report_id)
-
-                            if baseline is not None:
-                                baseline_throughput =
baseline.get_value('throughput').get_result()
-                                baseline_deviation =
baseline.get_value('throughput_deviation').get_result()
-                                netperf_cli_udp.update_options({'threshold':
'%s bits/sec' % baseline_throughput,
-                                                               
'threshold_deviation': '%s bits/sec' % baseline_deviation})
-
                         # Netperf test (both TCP and UDP)
                         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'])
+                        result_tcp.set_parameter(offload, state)
+                        result_tcp.set_parameter('netperf_server_on_vlan',
vlan1)
+                        result_tcp.set_parameter('netperf_client_on_vlan',
vlan2)
+                        result_tcp.add_tag(product_name)
+
+                        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)
-                        udp_res_data = m2.run(netperf_cli_udp6,
-                                              timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-                        srv_proc.intr()
 
-                        if result_tcp is not None and tcp_res_data.get_result() is not
None and\
-                           tcp_res_data.get_result()['res_data'] is not None:
-                            rate =
tcp_res_data.get_result()['res_data']['rate']
-                            deviation =
tcp_res_data.get_result()['res_data']['rate_deviation']
+                        netperf_result_template(result_tcp, tcp_res_data)
+                        perf_api.save_result(result_tcp)
 
-                            result_tcp.add_value('throughput', rate)
-                            result_tcp.add_value('throughput_min', rate -
deviation)
-                            result_tcp.add_value('throughput_max', rate +
deviation)
-                            result_tcp.add_value('throughput_deviation',
deviation)
-                            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'])
+                        result_udp.set_parameter(offload, state)
+                        result_udp.set_parameter('netperf_server_on_vlan',
vlan1)
+                        result_udp.set_parameter('netperf_client_on_vlan',
vlan2)
+                        result_udp.add_tag(product_name)
+
+                        baseline = perf_api.get_baseline_of_result(result_udp)
+                        netperf_baseline_template(netperf_cli_udp6, baseline)
 
-                        if result_udp is not None and udp_res_data.get_result() is not
None and\
-                           udp_res_data.get_result()['res_data'] is not None:
-                            rate =
udp_res_data.get_result()['res_data']['rate']
-                            deviation =
udp_res_data.get_result()['res_data']['rate_deviation']
+                        udp_res_data = m2.run(netperf_cli_udp6,
+                                              timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
 
-                            result_udp.add_value('throughput', rate)
-                            result_udp.add_value('throughput_min', rate -
deviation)
-                            result_udp.add_value('throughput_max', rate +
deviation)
-                            result_udp.add_value('throughput_deviation',
deviation)
-                            perf_api.save_result(result_udp)
+                        netperf_result_template(result_udp, udp_res_data)
+                        perf_api.save_result(result_udp)
 
+                        srv_proc.intr()
         # These tests should fail
         # Ping across different VLAN
         else:
diff --git a/recipes/regression_tests/phase2/team_test.py
b/recipes/regression_tests/phase2/team_test.py
index e132be9..e974ec2 100644
--- a/recipes/regression_tests/phase2/team_test.py
+++ b/recipes/regression_tests/phase2/team_test.py
@@ -1,31 +1,17 @@
 import logging
 from lnst.Controller.Task import ctl
-from lnst.Controller.PerfRepoUtils import parse_id_mapping, get_id
-
+from lnst.Controller.PerfRepoUtils import netperf_baseline_template
+from lnst.Controller.PerfRepoUtils import netperf_result_template
 
 # ------
 # SETUP
 # ------
 
 mapping_file = ctl.get_alias("mapping_file")
-mapping = parse_id_mapping(mapping_file)
+perf_api = ctl.connect_PerfRepo(mapping_file)
 
 product_name = ctl.get_alias("product_name")
 
-tcp_ipv4_id = get_id(mapping, "tcp_ipv4_id")
-tcp_ipv6_id = get_id(mapping, "tcp_ipv6_id")
-udp_ipv4_id = get_id(mapping, "udp_ipv4_id")
-udp_ipv6_id = get_id(mapping, "udp_ipv6_id")
-
-if tcp_ipv4_id is not None or\
-   tcp_ipv6_id is not None or\
-   udp_ipv4_id is not None or\
-   udp_ipv6_id is not None:
-    perf_api = ctl.connect_PerfRepo()
-    logging.info("PerfRepo support enabled for this run.")
-else:
-    logging.info("PerfRepo support disabled for this run.")
-
 m1 = ctl.get_host("testmachine1")
 m2 = ctl.get_host("testmachine2")
 
@@ -134,166 +120,97 @@ for offload in offloads:
         if ipv in [ 'ipv4', 'both' ]:
             m1.run(ping_mod)
 
-            # prepare PerfRepo result for tcp
-            result_tcp = None
-            result_udp = None
-            if tcp_ipv4_id is not None:
-                result_tcp = perf_api.new_result(tcp_ipv4_id,
"tcp_ipv4_result")
-                result_tcp.set_parameter(offload, state)
-                result_tcp.set_parameter('netperf_server',
"testmachine1")
-                result_tcp.set_parameter('netperf_client',
"testmachine2")
-                if product_name is not None:
-                    result_tcp.set_tag(product_name)
-                res_hash = result_tcp.generate_hash(['kernel_release',
-                                                     'redhat_release'])
-                result_tcp.set_tag(res_hash)
-
-                baseline = None
-                report_id = get_id(mapping, res_hash)
-                if report_id is not None:
-                    baseline = perf_api.get_baseline(report_id)
-
-                if baseline is not None:
-                    baseline_throughput =
baseline.get_value('throughput').get_result()
-                    baseline_deviation =
baseline.get_value('throughput_deviation').get_result()
-                    netperf_cli_tcp.update_options({'threshold': '%s
bits/sec' % baseline_throughput,
-                                                    'threshold_deviation':
'%s bits/sec' % baseline_deviation})
-
-            # prepare PerfRepo result for udp
-            if udp_ipv4_id is not None:
-                result_udp = perf_api.new_result(udp_ipv4_id,
"udp_ipv4_result")
-                result_udp.set_parameter(offload, state)
-                result_udp.set_parameter('netperf_server',
"testmachine1")
-                result_udp.set_parameter('netperf_client',
"testmachine2")
-                if product_name is not None:
-                    result_udp.set_tag(product_name)
-                res_hash = result_udp.generate_hash(['kernel_release',
-                                                     'redhat_release'])
-                result_udp.set_tag(res_hash)
-
-                baseline = None
-                report_id = get_id(mapping, res_hash)
-                if report_id is not None:
-                    baseline = perf_api.get_baseline(report_id)
-
-                if baseline is not None:
-                    baseline_throughput =
baseline.get_value('throughput').get_result()
-                    baseline_deviation =
baseline.get_value('throughput_deviation').get_result()
-                    netperf_cli_udp.update_options({'threshold': '%s
bits/sec' % baseline_throughput,
-                                                    'threshold_deviation':
'%s bits/sec' % baseline_deviation})
-
             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'])
+            result_tcp.set_parameter(offload, state)
+            result_tcp.set_parameter('netperf_server', "testmachine1")
+            result_tcp.set_parameter('netperf_client', "testmachine2")
+            result_tcp.add_tag(product_name)
+
+            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)
+            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'])
+            result_udp.set_parameter(offload, state)
+            result_udp.set_parameter('netperf_server', "testmachine1")
+            result_udp.set_parameter('netperf_client', "testmachine2")
+            result_udp.add_tag(product_name)
+
+            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)
-            server_proc.intr()
 
-            if result_tcp is not None and\
-               tcp_res_data.get_result() is not None and\
-               tcp_res_data.get_result()['res_data'] is not None:
-                rate = tcp_res_data.get_result()['res_data']['rate']
-                deviation =
tcp_res_data.get_result()['res_data']['rate_deviation']
-
-                result_tcp.add_value('throughput', rate)
-                result_tcp.add_value('throughput_min', rate - deviation)
-                result_tcp.add_value('throughput_max', rate + deviation)
-                result_tcp.add_value('throughput_deviation', deviation)
-                perf_api.save_result(result_tcp)
-
-            if result_udp is not None and udp_res_data.get_result() is not None and\
-               udp_res_data.get_result()['res_data'] is not None:
-                rate = udp_res_data.get_result()['res_data']['rate']
-                deviation =
udp_res_data.get_result()['res_data']['rate_deviation']
-
-                result_udp.add_value('throughput', rate)
-                result_udp.add_value('throughput_min', rate - deviation)
-                result_udp.add_value('throughput_max', rate + deviation)
-                result_udp.add_value('throughput_deviation', deviation)
-                perf_api.save_result(result_udp)
+            netperf_result_template(result_udp, udp_res_data)
+            perf_api.save_result(result_udp)
 
+            server_proc.intr()
         if ipv in [ 'ipv6', 'both' ]:
             m1.run(ping_mod6)
 
-            # prepare PerfRepo result for tcp
-            result_tcp = None
-            result_udp = None
-            if tcp_ipv6_id is not None:
-                result_tcp = perf_api.new_result(tcp_ipv6_id,
"tcp_ipv6_result")
-                result_tcp.set_parameter(offload, state)
-                result_tcp.set_parameter('netperf_server',
"testmachine1")
-                result_tcp.set_parameter('netperf_client',
"testmachine2")
-                if product_name is not None:
-                    result_tcp.set_tag(product_name)
-                res_hash = result_tcp.generate_hash(['kernel_release',
-                                                     'redhat_release'])
-                result_tcp.set_tag(res_hash)
-
-                baseline = None
-                report_id = get_id(mapping, res_hash)
-                if report_id is not None:
-                    baseline = perf_api.get_baseline(report_id)
-
-                if baseline is not None:
-                    baseline_throughput =
baseline.get_value('throughput').get_result()
-                    baseline_deviation =
baseline.get_value('throughput_deviation').get_result()
-                    netperf_cli_tcp.update_options({'threshold': '%s
bits/sec' % baseline_throughput,
-                                                    'threshold_deviation':
'%s bits/sec' % baseline_deviation})
-
-            # prepare PerfRepo result for udp
-            if udp_ipv6_id is not None:
-                result_udp = perf_api.new_result(udp_ipv4_id,
"udp_ipv6_result")
-                result_udp.set_parameter(offload, state)
-                result_udp.set_parameter('netperf_server',
"testmachine1")
-                result_udp.set_parameter('netperf_client',
"testmachine2")
-                if product_name is not None:
-                    result_udp.set_tag(product_name)
-                res_hash = result_udp.generate_hash(['kernel_release',
-                                                     'redhat_release'])
-                result_udp.set_tag(res_hash)
-
-                baseline = None
-                report_id = get_id(mapping, res_hash)
-                if report_id is not None:
-                    baseline = perf_api.get_baseline(report_id)
-
-                if baseline is not None:
-                    baseline_throughput =
baseline.get_value('throughput').get_result()
-                    baseline_deviation =
baseline.get_value('throughput_deviation').get_result()
-                    netperf_cli_udp.update_options({'threshold': '%s
bits/sec' % baseline_throughput,
-                                                    'threshold_deviation':
'%s bits/sec' % baseline_deviation})
-
             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'])
+            result_tcp.set_parameter(offload, state)
+            result_tcp.set_parameter('netperf_server', "testmachine1")
+            result_tcp.set_parameter('netperf_client', "testmachine2")
+            result_tcp.add_tag(product_name)
+
+            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)
-            udp_res_data = m2.run(netperf_cli_udp6,
-                                  timeout = (netperf_duration + nperf_reserve)*5)
-            server_proc.intr()
 
-            if result_tcp is not None and tcp_res_data.get_result() is not None and\
-               tcp_res_data.get_result()['res_data'] is not None:
-                rate = tcp_res_data.get_result()['res_data']['rate']
-                deviation =
tcp_res_data.get_result()['res_data']['rate_deviation']
+            netperf_result_template(result_tcp, tcp_res_data)
+            perf_api.save_result(result_tcp)
 
-                result_tcp.add_value('throughput', rate)
-                result_tcp.add_value('throughput_min', rate - deviation)
-                result_tcp.add_value('throughput_max', rate + deviation)
-                result_tcp.add_value('throughput_deviation', deviation)
-                perf_api.save_result(result_tcp)
+            # prepare PerfRepo result for udp
+            result_udp = perf_api.new_result("udp_ipv4_id",
+                                             "udp_ipv6_result",
+                                             hash_ignore=[
+                                                 'kernel_release',
+                                                 'redhat_release'])
+            result_udp.set_parameter(offload, state)
+            result_udp.set_parameter('netperf_server', "testmachine1")
+            result_udp.set_parameter('netperf_client', "testmachine2")
+            result_udp.add_tag(product_name)
+
+            baseline = perf_api.get_baseline_of_result(result_udp)
+            netperf_baseline_template(netperf_cli_udp6, baseline)
 
-            if result_udp is not None and udp_res_data.get_result() is not None and\
-               udp_res_data.get_result()['res_data'] is not None:
-                rate = udp_res_data.get_result()['res_data']['rate']
-                deviation =
udp_res_data.get_result()['res_data']['rate_deviation']
+            udp_res_data = m2.run(netperf_cli_udp6,
+                                  timeout = (netperf_duration + nperf_reserve)*5)
 
-                result_udp.add_value('throughput', rate)
-                result_udp.add_value('throughput_min', rate - deviation)
-                result_udp.add_value('throughput_max', rate + deviation)
-                result_udp.add_value('throughput_deviation', deviation)
-                perf_api.save_result(result_udp)
+            netperf_result_template(result_udp, udp_res_data)
+            perf_api.save_result(result_udp)
 
+            server_proc.intr()
 
 
 ping_mod.update_options({"addr" : m1.get_ip("test_if", 0),
@@ -327,158 +244,94 @@ for offload in offloads:
         if ipv in [ 'ipv4', 'both' ]:
             m2.run(ping_mod)
 
+            server_proc = m2.run(netperf_srv, bg=True)
+            ctl.wait(2)
+
             # prepare PerfRepo result for tcp
-            result_tcp = None
-            result_udp = None
-            if tcp_ipv4_id is not None:
-                result_tcp = perf_api.new_result(tcp_ipv4_id,
"tcp_ipv4_result")
-                result_tcp.set_parameter(offload, state)
-                result_tcp.set_parameter('netperf_server',
"testmachine2")
-                result_tcp.set_parameter('netperf_client',
"testmachine1")
-                if product_name is not None:
-                    result_tcp.set_tag(product_name)
-                res_hash = result_tcp.generate_hash(['kernel_release',
-                                                     'redhat_release'])
-                result_tcp.set_tag(res_hash)
-
-                baseline = None
-                report_id = get_id(mapping, res_hash)
-                if report_id is not None:
-                    baseline = perf_api.get_baseline(report_id)
-
-                if baseline is not None:
-                    baseline_throughput =
baseline.get_value('throughput').get_result()
-                    baseline_deviation =
baseline.get_value('throughput_deviation').get_result()
-                    netperf_cli_tcp.update_options({'threshold': '%s
bits/sec' % baseline_throughput,
-                                                    'threshold_deviation':
'%s bits/sec' % baseline_deviation})
+            result_tcp = perf_api.new_result("tcp_ipv4_id",
+                                             "tcp_ipv4_result",
+                                             hash_ignore=[
+                                                 'kernel_release',
+                                                 'redhat_release'])
+            result_tcp.set_parameter(offload, state)
+            result_tcp.set_parameter('netperf_server', "testmachine2")
+            result_tcp.set_parameter('netperf_client', "testmachine1")
+            result_tcp.add_tag(product_name)
+
+            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)
 
-            # prepare PerfRepo result for udp
-            if udp_ipv4_id is not None:
-                result_udp = perf_api.new_result(udp_ipv4_id,
"udp_ipv4_result")
-                result_udp.set_parameter(offload, state)
-                result_udp.set_parameter('netperf_server',
"testmachine2")
-                result_udp.set_parameter('netperf_client',
"testmachine1")
-                if product_name is not None:
-                    result_udp.set_tag(product_name)
-                res_hash = result_udp.generate_hash(['kernel_release',
-                                                     'redhat_release'])
-                result_udp.set_tag(res_hash)
-
-                baseline = None
-                report_id = get_id(mapping, res_hash)
-                if report_id is not None:
-                    baseline = perf_api.get_baseline(report_id)
-
-                if baseline is not None:
-                    baseline_throughput =
baseline.get_value('throughput').get_result()
-                    baseline_deviation =
baseline.get_value('throughput_deviation').get_result()
-                    netperf_cli_udp.update_options({'threshold': '%s
bits/sec' % baseline_throughput,
-                                                    'threshold_deviation':
'%s bits/sec' % baseline_deviation})
+            netperf_result_template(result_tcp, tcp_res_data)
+            perf_api.save_result(result_tcp)
 
-            server_proc = m2.run(netperf_srv, bg=True)
-            ctl.wait(2)
-            tcp_res_data = m1.run(netperf_cli_tcp, timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-            udp_res_data = m1.run(netperf_cli_udp, timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-            server_proc.intr()
+            # prepare PerfRepo result for udp
+            result_udp = perf_api.new_result("udp_ipv4_id",
+                                             "udp_ipv4_result",
+                                             hash_ignore=[
+                                                 'kernel_release',
+                                                 'redhat_release'])
+            result_udp.set_parameter(offload, state)
+            result_udp.set_parameter('netperf_server', "testmachine2")
+            result_udp.set_parameter('netperf_client', "testmachine1")
+            result_udp.add_tag(product_name)
+
+            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)
 
-            if result_tcp is not None and\
-               tcp_res_data.get_result() is not None and\
-               tcp_res_data.get_result()['res_data'] is not None:
-                rate = tcp_res_data.get_result()['res_data']['rate']
-                deviation =
tcp_res_data.get_result()['res_data']['rate_deviation']
-
-                result_tcp.add_value('throughput', rate)
-                result_tcp.add_value('throughput_min', rate - deviation)
-                result_tcp.add_value('throughput_max', rate + deviation)
-                result_tcp.add_value('throughput_deviation', deviation)
-                perf_api.save_result(result_tcp)
-
-            if result_udp is not None and udp_res_data.get_result() is not None and\
-               udp_res_data.get_result()['res_data'] is not None:
-                rate = udp_res_data.get_result()['res_data']['rate']
-                deviation =
udp_res_data.get_result()['res_data']['rate_deviation']
-
-                result_udp.add_value('throughput', rate)
-                result_udp.add_value('throughput_min', rate - deviation)
-                result_udp.add_value('throughput_max', rate + deviation)
-                result_udp.add_value('throughput_deviation', deviation)
-                perf_api.save_result(result_udp)
+            netperf_result_template(result_udp, udp_res_data)
+            perf_api.save_result(result_udp)
 
+            server_proc.intr()
         if ipv in [ 'ipv6', 'both' ]:
             m2.run(ping_mod6)
 
+            server_proc = m2.run(netperf_srv6, bg=True)
+            ctl.wait(2)
+
             # prepare PerfRepo result for tcp
-            result_tcp = None
-            result_udp = None
-            if tcp_ipv6_id is not None:
-                result_tcp = perf_api.new_result(tcp_ipv6_id,
"tcp_ipv6_result")
-                result_tcp.set_parameter(offload, state)
-                result_tcp.set_parameter('netperf_server',
"testmachine2")
-                result_tcp.set_parameter('netperf_client',
"testmachine1")
-                if product_name is not None:
-                    result_tcp.set_tag(product_name)
-                res_hash = result_tcp.generate_hash(['kernel_release',
-                                                     'redhat_release'])
-                result_tcp.set_tag(res_hash)
-
-                baseline = None
-                report_id = get_id(mapping, res_hash)
-                if report_id is not None:
-                    baseline = perf_api.get_baseline(report_id)
-
-                if baseline is not None:
-                    baseline_throughput =
baseline.get_value('throughput').get_result()
-                    baseline_deviation =
baseline.get_value('throughput_deviation').get_result()
-                    netperf_cli_tcp.update_options({'threshold': '%s
bits/sec' % baseline_throughput,
-                                                    'threshold_deviation':
'%s bits/sec' % baseline_deviation})
+            result_tcp = perf_api.new_result("tcp_ipv6_id",
+                                             "tcp_ipv6_result",
+                                             hash_ignore=[
+                                                 'kernel_release',
+                                                 'redhat_release'])
+            result_tcp.set_parameter(offload, state)
+            result_tcp.set_parameter('netperf_server', "testmachine2")
+            result_tcp.set_parameter('netperf_client', "testmachine1")
+            result_tcp.add_tag(product_name)
+
+            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)
+            perf_api.save_result(result_tcp)
 
             # prepare PerfRepo result for udp
-            if udp_ipv6_id is not None:
-                result_udp = perf_api.new_result(udp_ipv4_id,
"udp_ipv6_result")
-                result_udp.set_parameter(offload, state)
-                result_udp.set_parameter('netperf_server',
"testmachine2")
-                result_udp.set_parameter('netperf_client',
"testmachine1")
-                if product_name is not None:
-                    result_udp.set_tag(product_name)
-                res_hash = result_udp.generate_hash(['kernel_release',
-                                                     'redhat_release'])
-                result_udp.set_tag(res_hash)
-
-                baseline = None
-                report_id = get_id(mapping, res_hash)
-                if report_id is not None:
-                    baseline = perf_api.get_baseline(report_id)
-
-                if baseline is not None:
-                    baseline_throughput =
baseline.get_value('throughput').get_result()
-                    baseline_deviation =
baseline.get_value('throughput_deviation').get_result()
-                    netperf_cli_udp.update_options({'threshold': '%s
bits/sec' % baseline_throughput,
-                                                    'threshold_deviation':
'%s bits/sec' % baseline_deviation})
+            result_udp = perf_api.new_result("udp_ipv4_id",
+                                             "udp_ipv6_result",
+                                             hash_ignore=[
+                                                 'kernel_release',
+                                                 'redhat_release'])
+            result_udp.set_parameter(offload, state)
+            result_udp.set_parameter('netperf_server', "testmachine2")
+            result_udp.set_parameter('netperf_client', "testmachine1")
+            result_udp.add_tag(product_name)
+
+            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)
 
-            server_proc = m2.run(netperf_srv6, bg=True)
-            ctl.wait(2)
-            tcp_res_data = m1.run(netperf_cli_tcp6, timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-            udp_res_data = m1.run(netperf_cli_udp6, timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-            server_proc.intr()
+            netperf_result_template(result_udp, udp_res_data)
+            perf_api.save_result(result_udp)
 
-            if result_tcp is not None and tcp_res_data.get_result() is not None and\
-               tcp_res_data.get_result()['res_data'] is not None:
-                rate = tcp_res_data.get_result()['res_data']['rate']
-                deviation =
tcp_res_data.get_result()['res_data']['rate_deviation']
-
-                result_tcp.add_value('throughput', rate)
-                result_tcp.add_value('throughput_min', rate - deviation)
-                result_tcp.add_value('throughput_max', rate + deviation)
-                result_tcp.add_value('throughput_deviation', deviation)
-                perf_api.save_result(result_tcp)
-
-            if result_udp is not None and udp_res_data.get_result() is not None and\
-               udp_res_data.get_result()['res_data'] is not None:
-                rate = udp_res_data.get_result()['res_data']['rate']
-                deviation =
udp_res_data.get_result()['res_data']['rate_deviation']
-
-                result_udp.add_value('throughput', rate)
-                result_udp.add_value('throughput_min', rate - deviation)
-                result_udp.add_value('throughput_max', rate + deviation)
-                result_udp.add_value('throughput_deviation', deviation)
-                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 fa7961c..6ba9541 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
@@ -1,30 +1,17 @@
 import logging
 from lnst.Controller.Task import ctl
-from lnst.Controller.PerfRepoUtils import parse_id_mapping, get_id
+from lnst.Controller.PerfRepoUtils import netperf_baseline_template
+from lnst.Controller.PerfRepoUtils import netperf_result_template
 
 # ------
 # SETUP
 # ------
 
 mapping_file = ctl.get_alias("mapping_file")
-mapping = parse_id_mapping(mapping_file)
+perf_api = ctl.connect_PerfRepo(mapping_file)
 
 product_name = ctl.get_alias("product_name")
 
-tcp_ipv4_id = get_id(mapping, "tcp_ipv4_id")
-tcp_ipv6_id = get_id(mapping, "tcp_ipv6_id")
-udp_ipv4_id = get_id(mapping, "udp_ipv4_id")
-udp_ipv6_id = get_id(mapping, "udp_ipv6_id")
-
-if tcp_ipv4_id is not None or\
-   tcp_ipv6_id is not None or\
-   udp_ipv4_id is not None or\
-   udp_ipv6_id is not None:
-    perf_api = ctl.connect_PerfRepo()
-    logging.info("PerfRepo support enabled for this run.")
-else:
-    logging.info("PerfRepo support disabled for this run.")
-
 # Host 1 + guests 1 and 2
 h1 = ctl.get_host("host1")
 g1 = ctl.get_host("guest1")
@@ -201,156 +188,89 @@ for offload in offloads:
             g1.run(ping_mod_bad, expect="fail")
             g3.run(ping_mod_bad2, expect="fail")
 
-            # prepare PerfRepo result for tcp
-            result_tcp = None
-            result_udp = None
-            if tcp_ipv4_id is not None:
-                result_tcp = perf_api.new_result(tcp_ipv4_id,
"tcp_ipv4_result")
-                result_tcp.set_parameter(offload, state)
-                if product_name is not None:
-                    result_tcp.set_tag(product_name)
-                res_hash = result_tcp.generate_hash(['kernel_release',
-                                                     'redhat_release'])
-                result_tcp.set_tag(res_hash)
-
-                baseline = None
-                report_id = get_id(mapping, res_hash)
-                if report_id is not None:
-                    baseline = perf_api.get_baseline(report_id)
-
-                if baseline is not None:
-                    baseline_throughput =
baseline.get_value('throughput').get_result()
-                    baseline_deviation =
baseline.get_value('throughput_deviation').get_result()
-                    netperf_cli_tcp.update_options({'threshold': '%s
bits/sec' % baseline_throughput,
-                                                    'threshold_deviation':
'%s bits/sec' % baseline_deviation})
-            # prepare PerfRepo result for udp
-            if udp_ipv4_id is not None:
-                result_udp = perf_api.new_result(udp_ipv4_id,
"udp_ipv4_result")
-                result_udp.set_parameter(offload, state)
-                if product_name is not None:
-                    result_udp.set_tag(product_name)
-                res_hash = result_udp.generate_hash(['kernel_release',
-                                                     'redhat_release'])
-                result_udp.set_tag(res_hash)
-
-                baseline = None
-                report_id = get_id(mapping, res_hash)
-                if report_id is not None:
-                    baseline = perf_api.get_baseline(report_id)
-
-                if baseline is not None:
-                    baseline_throughput =
baseline.get_value('throughput').get_result()
-                    baseline_deviation =
baseline.get_value('throughput_deviation').get_result()
-                    netperf_cli_udp.update_options({'threshold': '%s
bits/sec' % baseline_throughput,
-                                                    'threshold_deviation':
'%s bits/sec' % baseline_deviation})
-
             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'])
+            result_tcp.set_parameter(offload, state)
+            result_tcp.add_tag(product_name)
+
+            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)
+            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'])
+            result_udp.set_parameter(offload, state)
+            result_udp.add_tag(product_name)
+
+            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)
-            server_proc.intr()
 
-            if result_tcp is not None and\
-               tcp_res_data.get_result() is not None and\
-               tcp_res_data.get_result()['res_data'] is not None:
-                rate = tcp_res_data.get_result()['res_data']['rate']
-                deviation =
tcp_res_data.get_result()['res_data']['rate_deviation']
-
-                result_tcp.add_value('throughput', rate)
-                result_tcp.add_value('throughput_min', rate - deviation)
-                result_tcp.add_value('throughput_max', rate + deviation)
-                result_tcp.add_value('throughput_deviation', deviation)
-                perf_api.save_result(result_tcp)
-
-            if result_udp is not None and udp_res_data.get_result() is not None and\
-               udp_res_data.get_result()['res_data'] is not None:
-                rate = udp_res_data.get_result()['res_data']['rate']
-                deviation =
udp_res_data.get_result()['res_data']['rate_deviation']
-
-                result_udp.add_value('throughput', rate)
-                result_udp.add_value('throughput_min', rate - deviation)
-                result_udp.add_value('throughput_max', rate + deviation)
-                result_udp.add_value('throughput_deviation', deviation)
-                perf_api.save_result(result_udp)
+            netperf_result_template(result_udp, udp_res_data)
+            perf_api.save_result(result_udp)
 
+            server_proc.intr()
         if ipv in [ 'ipv6', 'both' ]:
             g1.run(ping_mod6)
             g4.run(ping_mod62)
             g1.run(ping_mod6_bad, expect="fail")
             g3.run(ping_mod6_bad2, expect="fail")
 
+            server_proc = g1.run(netperf_srv6, bg=True)
+            ctl.wait(2)
+
             # prepare PerfRepo result for tcp ipv6
-            result_tcp = None
-            result_udp = None
-            if tcp_ipv6_id is not None:
-                result_tcp = perf_api.new_result(tcp_ipv6_id,
"tcp_ipv6_result")
-                result_tcp.set_parameter(offload, state)
-                if product_name is not None:
-                    result_tcp.set_tag(product_name)
-                res_hash = result_tcp.generate_hash(['kernel_release',
-                                                     'redhat_release'])
-                result_tcp.set_tag(res_hash)
-
-                baseline = None
-                report_id = get_id(mapping, res_hash)
-                if report_id is not None:
-                    baseline = perf_api.get_baseline(report_id)
-
-                if baseline is not None:
-                    baseline_throughput =
baseline.get_value('throughput').get_result()
-                    baseline_deviation =
baseline.get_value('throughput_deviation').get_result()
-                    netperf_cli_tcp.update_options({'threshold': '%s
bits/sec' % baseline_throughput,
-                                                    'threshold_deviation':
'%s bits/sec' % baseline_deviation})
+            result_tcp = perf_api.new_result("tcp_ipv6_id",
+                                             "tcp_ipv6_result",
+                                             hash_ignore=[
+                                                 'kernel_release',
+                                                 'redhat_release'])
+            result_tcp.set_parameter(offload, state)
+            result_tcp.add_tag(product_name)
 
-            # prepare PerfRepo result for udp ipv6
-            if udp_ipv6_id is not None:
-                result_udp = perf_api.new_result(udp_ipv6_id,
"udp_ipv6_result")
-                result_udp.set_parameter(offload, state)
-                if product_name is not None:
-                    result_udp.set_tag(product_name)
-                res_hash = result_udp.generate_hash(['kernel_release',
-                                                     'redhat_release'])
-                result_udp.set_tag(res_hash)
-
-                baseline = None
-                report_id = get_id(mapping, res_hash)
-                if report_id is not None:
-                    baseline = perf_api.get_baseline(report_id)
-
-                if baseline is not None:
-                    baseline_throughput =
baseline.get_value('throughput').get_result()
-                    baseline_deviation =
baseline.get_value('throughput_deviation').get_result()
-                    netperf_cli_udp.update_options({'threshold': '%s
bits/sec' % baseline_throughput,
-                                                    'threshold_deviation':
'%s bits/sec' % baseline_deviation})
+            baseline = perf_api.get_baseline_of_result(result_tcp)
+            netperf_baseline_template(netperf_cli_tcp6, baseline)
 
-            server_proc = g1.run(netperf_srv6, bg=True)
-            ctl.wait(2)
             tcp_res_data = g3.run(netperf_cli_tcp6,
                                   timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+            netperf_result_template(result_tcp, tcp_res_data)
+            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'])
+            result_udp.set_parameter(offload, state)
+            result_udp.add_tag(product_name)
+
+            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)
-            server_proc.intr()
 
-            if result_tcp is not None and tcp_res_data.get_result() is not None and\
-               tcp_res_data.get_result()['res_data'] is not None:
-                rate = tcp_res_data.get_result()['res_data']['rate']
-                deviation =
tcp_res_data.get_result()['res_data']['rate_deviation']
-
-                result_tcp.add_value('throughput', rate)
-                result_tcp.add_value('throughput_min', rate - deviation)
-                result_tcp.add_value('throughput_max', rate + deviation)
-                result_tcp.add_value('throughput_deviation', deviation)
-                perf_api.save_result(result_tcp)
-
-            if result_udp is not None and udp_res_data.get_result() is not None and\
-               udp_res_data.get_result()['res_data'] is not None:
-                rate = udp_res_data.get_result()['res_data']['rate']
-                deviation =
udp_res_data.get_result()['res_data']['rate_deviation']
-
-                result_udp.add_value('throughput', rate)
-                result_udp.add_value('throughput_min', rate - deviation)
-                result_udp.add_value('throughput_max', rate + deviation)
-                result_udp.add_value('throughput_deviation', deviation)
-                perf_api.save_result(result_udp)
+            netperf_result_template(result_udp, udp_res_data)
+            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 d953ab7..3a09ec0 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
@@ -1,30 +1,17 @@
 import logging
 from lnst.Controller.Task import ctl
-from lnst.Controller.PerfRepoUtils import parse_id_mapping, get_id
+from lnst.Controller.PerfRepoUtils import netperf_baseline_template
+from lnst.Controller.PerfRepoUtils import netperf_result_template
 
 # ------
 # SETUP
 # ------
 
 mapping_file = ctl.get_alias("mapping_file")
-mapping = parse_id_mapping(mapping_file)
+perf_api = ctl.connect_PerfRepo(mapping_file)
 
 product_name = ctl.get_alias("product_name")
 
-tcp_ipv4_id = get_id(mapping, "tcp_ipv4_id")
-tcp_ipv6_id = get_id(mapping, "tcp_ipv6_id")
-udp_ipv4_id = get_id(mapping, "udp_ipv4_id")
-udp_ipv6_id = get_id(mapping, "udp_ipv6_id")
-
-if tcp_ipv4_id is not None or\
-   tcp_ipv6_id is not None or\
-   udp_ipv4_id is not None or\
-   udp_ipv6_id is not None:
-    perf_api = ctl.connect_PerfRepo()
-    logging.info("PerfRepo support enabled for this run.")
-else:
-    logging.info("PerfRepo support disabled for this run.")
-
 h1 = ctl.get_host("host1")
 g1 = ctl.get_host("guest1")
 
@@ -133,155 +120,86 @@ for offload in offloads:
         if ipv in [ 'ipv4', 'both' ]:
             g1.run(ping_mod)
 
-            # prepare PerfRepo result for tcp
-            result_tcp = None
-            result_udp = None
-            if tcp_ipv4_id is not None:
-                result_tcp = perf_api.new_result(tcp_ipv4_id,
"tcp_ipv4_result")
-                result_tcp.set_parameter(offload, state)
-                if product_name is not None:
-                    result_tcp.set_tag(product_name)
-                res_hash = result_tcp.generate_hash(['kernel_release',
-                                                     'redhat_release'])
-                result_tcp.set_tag(res_hash)
-
-                baseline = None
-                report_id = get_id(mapping, res_hash)
-                if report_id is not None:
-                    baseline = perf_api.get_baseline(report_id)
-
-                if baseline is not None:
-                    baseline_throughput =
baseline.get_value('throughput').get_result()
-                    baseline_deviation =
baseline.get_value('throughput_deviation').get_result()
-                    netperf_cli_tcp.update_options({'threshold': '%s
bits/sec' % baseline_throughput,
-                                                    'threshold_deviation':
'%s bits/sec' % baseline_deviation})
-            # prepare PerfRepo result for udp
-            if udp_ipv4_id is not None:
-                result_udp = perf_api.new_result(udp_ipv4_id,
"udp_ipv4_result")
-                result_udp.set_parameter(offload, state)
-                if product_name is not None:
-                    result_udp.set_tag(product_name)
-                res_hash = result_udp.generate_hash(['kernel_release',
-                                                     'redhat_release'])
-                result_udp.set_tag(res_hash)
-
-                baseline = None
-                report_id = get_id(mapping, res_hash)
-                if report_id is not None:
-                    baseline = perf_api.get_baseline(report_id)
-
-                if baseline is not None:
-                    baseline_throughput =
baseline.get_value('throughput').get_result()
-                    baseline_deviation =
baseline.get_value('throughput_deviation').get_result()
-                    netperf_cli_udp.update_options({'threshold': '%s
bits/sec' % baseline_throughput,
-                                                    'threshold_deviation':
'%s bits/sec' % baseline_deviation})
-
             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'])
+            result_tcp.set_parameter(offload, state)
+            result_tcp.add_tag(product_name)
+
+            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)
+            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'])
+            result_udp.set_parameter(offload, state)
+            result_udp.add_tag(product_name)
+
+            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)
 
-            server_proc.intr()
-
-            if result_tcp is not None and\
-               tcp_res_data.get_result() is not None and\
-               tcp_res_data.get_result()['res_data'] is not None:
-                rate = tcp_res_data.get_result()['res_data']['rate']
-                deviation =
tcp_res_data.get_result()['res_data']['rate_deviation']
-
-                result_tcp.add_value('throughput', rate)
-                result_tcp.add_value('throughput_min', rate - deviation)
-                result_tcp.add_value('throughput_max', rate + deviation)
-                result_tcp.add_value('throughput_deviation', deviation)
-                perf_api.save_result(result_tcp)
-
-            if result_udp is not None and udp_res_data.get_result() is not None and\
-               udp_res_data.get_result()['res_data'] is not None:
-                rate = udp_res_data.get_result()['res_data']['rate']
-                deviation =
udp_res_data.get_result()['res_data']['rate_deviation']
-
-                result_udp.add_value('throughput', rate)
-                result_udp.add_value('throughput_min', rate - deviation)
-                result_udp.add_value('throughput_max', rate + deviation)
-                result_udp.add_value('throughput_deviation', deviation)
-                perf_api.save_result(result_udp)
+            netperf_result_template(result_udp, udp_res_data)
+            perf_api.save_result(result_udp)
 
+            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 = None
-            result_udp = None
-            if tcp_ipv6_id is not None:
-                result_tcp = perf_api.new_result(tcp_ipv6_id,
"tcp_ipv6_result")
-                result_tcp.set_parameter(offload, state)
-                if product_name is not None:
-                    result_tcp.set_tag(product_name)
-                res_hash = result_tcp.generate_hash(['kernel_release',
-                                                     'redhat_release'])
-                result_tcp.set_tag(res_hash)
-
-                baseline = None
-                report_id = get_id(mapping, res_hash)
-                if report_id is not None:
-                    baseline = perf_api.get_baseline(report_id)
-
-                if baseline is not None:
-                    baseline_throughput =
baseline.get_value('throughput').get_result()
-                    baseline_deviation =
baseline.get_value('throughput_deviation').get_result()
-                    netperf_cli_tcp.update_options({'threshold': '%s
bits/sec' % baseline_throughput,
-                                                    'threshold_deviation':
'%s bits/sec' % baseline_deviation})
+            result_tcp = perf_api.new_result("tcp_ipv6_id",
+                                             "tcp_ipv6_result",
+                                             hash_ignore=[
+                                                 'kernel_release',
+                                                 'redhat_release'])
+            result_tcp.set_parameter(offload, state)
+            result_tcp.add_tag(product_name)
 
-            # prepare PerfRepo result for udp ipv6
-            if udp_ipv6_id is not None:
-                result_udp = perf_api.new_result(udp_ipv6_id,
"udp_ipv6_result")
-                result_udp.set_parameter(offload, state)
-                if product_name is not None:
-                    result_udp.set_tag(product_name)
-                res_hash = result_udp.generate_hash(['kernel_release',
-                                                     'redhat_release'])
-                result_udp.set_tag(res_hash)
-
-                baseline = None
-                report_id = get_id(mapping, res_hash)
-                if report_id is not None:
-                    baseline = perf_api.get_baseline(report_id)
-
-                if baseline is not None:
-                    baseline_throughput =
baseline.get_value('throughput').get_result()
-                    baseline_deviation =
baseline.get_value('throughput_deviation').get_result()
-                    netperf_cli_udp.update_options({'threshold': '%s
bits/sec' % baseline_throughput,
-                                                    'threshold_deviation':
'%s bits/sec' % baseline_deviation})
+            baseline = perf_api.get_baseline_of_result(result_tcp)
+            netperf_baseline_template(netperf_cli_tcp6, baseline)
 
-            server_proc = g1.run(netperf_srv6, bg=True)
-            ctl.wait(2)
             tcp_res_data = h2.run(netperf_cli_tcp6,
                                   timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+            netperf_result_template(result_tcp, tcp_res_data)
+            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'])
+            result_udp.set_parameter(offload, state)
+            result_udp.add_tag(product_name)
+
+            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)
 
-            server_proc.intr()
+            netperf_result_template(result_udp, udp_res_data)
+            perf_api.save_result(result_udp)
 
-            if result_tcp is not None and tcp_res_data.get_result() is not None and\
-               tcp_res_data.get_result()['res_data'] is not None:
-                rate = tcp_res_data.get_result()['res_data']['rate']
-                deviation =
tcp_res_data.get_result()['res_data']['rate_deviation']
-
-                result_tcp.add_value('throughput', rate)
-                result_tcp.add_value('throughput_min', rate - deviation)
-                result_tcp.add_value('throughput_max', rate + deviation)
-                result_tcp.add_value('throughput_deviation', deviation)
-                perf_api.save_result(result_tcp)
-
-            if result_udp is not None and udp_res_data.get_result() is not None and\
-               udp_res_data.get_result()['res_data'] is not None:
-                rate = udp_res_data.get_result()['res_data']['rate']
-                deviation =
udp_res_data.get_result()['res_data']['rate_deviation']
-
-                result_udp.add_value('throughput', rate)
-                result_udp.add_value('throughput_min', rate - deviation)
-                result_udp.add_value('throughput_max', rate + deviation)
-                result_udp.add_value('throughput_deviation', deviation)
-                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 058f9ea..6e1cc74 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
@@ -1,30 +1,17 @@
 import logging
 from lnst.Controller.Task import ctl
-from lnst.Controller.PerfRepoUtils import parse_id_mapping, get_id
+from lnst.Controller.PerfRepoUtils import netperf_baseline_template
+from lnst.Controller.PerfRepoUtils import netperf_result_template
 
 # ------
 # SETUP
 # ------
 
 mapping_file = ctl.get_alias("mapping_file")
-mapping = parse_id_mapping(mapping_file)
+perf_api = ctl.connect_PerfRepo(mapping_file)
 
 product_name = ctl.get_alias("product_name")
 
-tcp_ipv4_id = get_id(mapping, "tcp_ipv4_id")
-tcp_ipv6_id = get_id(mapping, "tcp_ipv6_id")
-udp_ipv4_id = get_id(mapping, "udp_ipv4_id")
-udp_ipv6_id = get_id(mapping, "udp_ipv6_id")
-
-if tcp_ipv4_id is not None or\
-   tcp_ipv6_id is not None or\
-   udp_ipv4_id is not None or\
-   udp_ipv6_id is not None:
-    perf_api = ctl.connect_PerfRepo()
-    logging.info("PerfRepo support enabled for this run.")
-else:
-    logging.info("PerfRepo support disabled for this run.")
-
 h1 = ctl.get_host("host1")
 g1 = ctl.get_host("guest1")
 
@@ -132,153 +119,87 @@ for offload in offloads:
         if ipv in [ 'ipv4', 'both' ]:
             g1.run(ping_mod)
 
-            # prepare PerfRepo result for tcp
-            result_tcp = None
-            result_udp = None
-            if tcp_ipv4_id is not None:
-                result_tcp = perf_api.new_result(tcp_ipv4_id,
"tcp_ipv4_result")
-                result_tcp.set_parameter(offload, state)
-                if product_name is not None:
-                    result_tcp.set_tag(product_name)
-                res_hash = result_tcp.generate_hash(['kernel_release',
-                                                     'redhat_release'])
-                result_tcp.set_tag(res_hash)
-
-                baseline = None
-                report_id = get_id(mapping, res_hash)
-                if report_id is not None:
-                    baseline = perf_api.get_baseline(report_id)
-
-                if baseline is not None:
-                    baseline_throughput =
baseline.get_value('throughput').get_result()
-                    baseline_deviation =
baseline.get_value('throughput_deviation').get_result()
-                    netperf_cli_tcp.update_options({'threshold': '%s
bits/sec' % baseline_throughput,
-                                                    'threshold_deviation':
'%s bits/sec' % baseline_deviation})
-            # prepare PerfRepo result for udp
-            if udp_ipv4_id is not None:
-                result_udp = perf_api.new_result(udp_ipv4_id,
"udp_ipv4_result")
-                result_udp.set_parameter(offload, state)
-                if product_name is not None:
-                    result_udp.set_tag(product_name)
-                res_hash = result_udp.generate_hash(['kernel_release',
-                                                     'redhat_release'])
-                result_udp.set_tag(res_hash)
-
-                baseline = None
-                report_id = get_id(mapping, res_hash)
-                if report_id is not None:
-                    baseline = perf_api.get_baseline(report_id)
-
-                if baseline is not None:
-                    baseline_throughput =
baseline.get_value('throughput').get_result()
-                    baseline_deviation =
baseline.get_value('throughput_deviation').get_result()
-                    netperf_cli_udp.update_options({'threshold': '%s
bits/sec' % baseline_throughput,
-                                                    'threshold_deviation':
'%s bits/sec' % baseline_deviation})
-
             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'])
+            result_tcp.set_parameter(offload, state)
+            result_tcp.add_tag(product_name)
+
+            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)
+            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'])
+            result_udp.set_parameter(offload, state)
+            result_udp.add_tag(product_name)
+
+            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)
-            server_proc.intr()
 
-            if result_tcp is not None and\
-               tcp_res_data.get_result() is not None and\
-               tcp_res_data.get_result()['res_data'] is not None:
-                rate = tcp_res_data.get_result()['res_data']['rate']
-                deviation =
tcp_res_data.get_result()['res_data']['rate_deviation']
-
-                result_tcp.add_value('throughput', rate)
-                result_tcp.add_value('throughput_min', rate - deviation)
-                result_tcp.add_value('throughput_max', rate + deviation)
-                result_tcp.add_value('throughput_deviation', deviation)
-                perf_api.save_result(result_tcp)
-
-            if result_udp is not None and udp_res_data.get_result() is not None and\
-               udp_res_data.get_result()['res_data'] is not None:
-                rate = udp_res_data.get_result()['res_data']['rate']
-                deviation =
udp_res_data.get_result()['res_data']['rate_deviation']
-
-                result_udp.add_value('throughput', rate)
-                result_udp.add_value('throughput_min', rate - deviation)
-                result_udp.add_value('throughput_max', rate + deviation)
-                result_udp.add_value('throughput_deviation', deviation)
-                perf_api.save_result(result_udp)
+            netperf_result_template(result_udp, udp_res_data)
+            perf_api.save_result(result_udp)
+
+            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 = None
-            result_udp = None
-            if tcp_ipv6_id is not None:
-                result_tcp = perf_api.new_result(tcp_ipv6_id,
"tcp_ipv6_result")
-                result_tcp.set_parameter(offload, state)
-                if product_name is not None:
-                    result_tcp.set_tag(product_name)
-                res_hash = result_tcp.generate_hash(['kernel_release',
-                                                     'redhat_release'])
-                result_tcp.set_tag(res_hash)
-
-                baseline = None
-                report_id = get_id(mapping, res_hash)
-                if report_id is not None:
-                    baseline = perf_api.get_baseline(report_id)
-
-                if baseline is not None:
-                    baseline_throughput =
baseline.get_value('throughput').get_result()
-                    baseline_deviation =
baseline.get_value('throughput_deviation').get_result()
-                    netperf_cli_tcp.update_options({'threshold': '%s
bits/sec' % baseline_throughput,
-                                                    'threshold_deviation':
'%s bits/sec' % baseline_deviation})
+            result_tcp = perf_api.new_result("tcp_ipv6_id",
+                                             "tcp_ipv6_result",
+                                             hash_ignore=[
+                                                 'kernel_release',
+                                                 'redhat_release'])
+            result_tcp.set_parameter(offload, state)
+            result_tcp.add_tag(product_name)
 
-            # prepare PerfRepo result for udp ipv6
-            if udp_ipv6_id is not None:
-                result_udp = perf_api.new_result(udp_ipv6_id,
"udp_ipv6_result")
-                result_udp.set_parameter(offload, state)
-                if product_name is not None:
-                    result_udp.set_tag(product_name)
-                res_hash = result_udp.generate_hash(['kernel_release',
-                                                     'redhat_release'])
-                result_udp.set_tag(res_hash)
-
-                baseline = None
-                report_id = get_id(mapping, res_hash)
-                if report_id is not None:
-                    baseline = perf_api.get_baseline(report_id)
-
-                if baseline is not None:
-                    baseline_throughput =
baseline.get_value('throughput').get_result()
-                    baseline_deviation =
baseline.get_value('throughput_deviation').get_result()
-                    netperf_cli_udp.update_options({'threshold': '%s
bits/sec' % baseline_throughput,
-                                                    'threshold_deviation':
'%s bits/sec' % baseline_deviation})
+            baseline = perf_api.get_baseline_of_result(result_tcp)
+            netperf_baseline_template(netperf_cli_tcp6, baseline)
 
-            server_proc = g1.run(netperf_srv6, bg=True)
-            ctl.wait(2)
             tcp_res_data = h2.run(netperf_cli_tcp6,
                                   timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+            netperf_result_template(result_tcp, tcp_res_data)
+            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'])
+            result_udp.set_parameter(offload, state)
+            result_udp.add_tag(product_name)
+
+            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)
-            server_proc.intr()
 
-            if result_tcp is not None and tcp_res_data.get_result() is not None and\
-               tcp_res_data.get_result()['res_data'] is not None:
-                rate = tcp_res_data.get_result()['res_data']['rate']
-                deviation =
tcp_res_data.get_result()['res_data']['rate_deviation']
-
-                result_tcp.add_value('throughput', rate)
-                result_tcp.add_value('throughput_min', rate - deviation)
-                result_tcp.add_value('throughput_max', rate + deviation)
-                result_tcp.add_value('throughput_deviation', deviation)
-                perf_api.save_result(result_tcp)
-
-            if result_udp is not None and udp_res_data.get_result() is not None and\
-               udp_res_data.get_result()['res_data'] is not None:
-                rate = udp_res_data.get_result()['res_data']['rate']
-                deviation =
udp_res_data.get_result()['res_data']['rate_deviation']
-
-                result_udp.add_value('throughput', rate)
-                result_udp.add_value('throughput_min', rate - deviation)
-                result_udp.add_value('throughput_max', rate + deviation)
-                result_udp.add_value('throughput_deviation', deviation)
-                perf_api.save_result(result_udp)
+            netperf_result_template(result_udp, udp_res_data)
+            perf_api.save_result(result_udp)
+
+            server_proc.intr()
-- 
2.6.0