示例#1
0
            result_tcp.set_parameter('msg_size', nperf_msg_size)
            result_tcp.set_parameter('ipsec_mode', ipsec_mode)

            baseline = perf_api.get_baseline_of_result(result_tcp)
            baseline = perfrepo_baseline_to_dict(baseline)

            tcp_res_data = netperf(
                (m1, m1_if, 0, {
                    "scope": 0
                }), (m2, m2_if, 0, {
                    "scope": 0
                }),
                client_opts={
                    "duration": netperf_duration,
                    "testname": "TCP_STREAM",
                    "confidence": nperf_confidence,
                    "num_parallel": nperf_num_parallel,
                    "cpu_util": nperf_cpu_util,
                    "runs": nperf_max_runs,
                    "debug": nperf_debug,
                    "max_deviation": nperf_max_dev,
                    "msg_size": nperf_msg_size,
                    "netperf_opts": nperf_opts
                },
                baseline=baseline,
                timeout=(netperf_duration + nperf_reserve) * nperf_max_runs)

            netperf_result_template(result_tcp, tcp_res_data)
            result_tcp.set_comment(pr_comment)
            perf_api.save_result(result_tcp, official_result)

            # prepare PerfRepo result for udp
示例#2
0
        if nperf_num_parallel > 1:
            result_tcp.add_tag("multithreaded")
            result_tcp.set_parameter('num_parallel', nperf_num_parallel)

        if nperf_msg_size is not None:
            result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)

        baseline = perf_api.get_baseline_of_result(result_tcp)
        baseline = perfrepo_baseline_to_dict(baseline)

        client_opts["testname"] = "TCP_STREAM"
        client_opts["netperf_opts"] = nperf_opts

        tcp_res_data = netperf(
            (guest1, g1_nic, 0), (guest3, g3_nic, 0),
            client_opts=client_opts,
            baseline=baseline,
            timeout=(netperf_duration + nperf_reserve) * nperf_max_runs)

        netperf_result_template(result_tcp, tcp_res_data)
        result_tcp.set_comment(pr_comment)
        perf_api.save_result(result_tcp, official_result)

    if nperf_protocols.find("udp") > -1:
        # prepare PerfRepo result for udp
        result_udp = perf_api.new_result(
            "udp_ipv4_id",
            "udp_ipv4_result",
            hash_ignore=[
                r'kernel_release', r'redhat_release',
                r'test_host\d+\.hostname', r'test_host\d+\..*hwaddr',
示例#3
0
                                         r'test_if\.hwaddr'])
    result_tcp.add_tag(product_name)
    if nperf_num_parallel > 1:
        result_tcp.add_tag("multithreaded")
        result_tcp.set_parameter('num_parallel', nperf_num_parallel)

    baseline = perf_api.get_baseline_of_result(result_tcp)
    baseline = perfrepo_baseline_to_dict(baseline)

    tcp_res_data = netperf((m1, test_if1, 0, {"scope": 0}),
                           (m2, test_if2, 0, {"scope": 0}),
                           client_opts={"duration" : netperf_duration,
                                        "testname" : "TCP_STREAM",
                                        "confidence" : nperf_confidence,
                                        "num_parallel" : nperf_num_parallel,
                                        "cpu_util" : nperf_cpu_util,
                                        "runs": nperf_max_runs,
                                        "debug": nperf_debug,
                                        "max_deviation": nperf_max_dev,
                                        "netperf_opts": nperf_opts},
                           baseline = baseline,
                           timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)

    netperf_result_template(result_tcp, tcp_res_data)
    result_tcp.set_comment(pr_comment)
    perf_api.save_result(result_tcp)

    # prepare PerfRepo result for udp
    result_udp = perf_api.new_result("udp_ipv4_id",
                                     "udp_ipv4_result",
                                     hash_ignore=[
示例#4
0
            result_tcp.set_parameter('num_parallel', nperf_num_parallel)

        if nperf_msg_size is not None:
            result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)

        baseline = perf_api.get_baseline_of_result(result_tcp)
        baseline = perfrepo_baseline_to_dict(baseline)

        client_opts["testname"] = "TCP_STREAM"
        client_opts["netperf_opts"] = nperf_opts

        tcp_res_data = netperf(
            (h1, h1_nic, 0, {
                "scope": 0
            }), (h2, h2_nic, 0, {
                "scope": 0
            }),
            client_opts=client_opts,
            baseline=baseline,
            timeout=(netperf_duration + nperf_reserve) * nperf_max_runs)

        netperf_result_template(result_tcp, tcp_res_data)
        result_tcp.set_comment(pr_comment)
        perf_api.save_result(result_tcp, official_result)

    if nperf_protocols.find("udp") > -1:
        # prepare PerfRepo result for udp
        result_udp = perf_api.new_result("udp_ipv4_id",
                                         "udp_ipv4_result",
                                         hash_ignore=[
                                             r'kernel_release',
示例#5
0
        result_tcp.add_tag(product_name)
        if nperf_num_parallel > 1:
            result_tcp.add_tag("multithreaded")
            result_tcp.set_parameter('num_parallel', nperf_num_parallel)

        if nperf_msg_size is not None:
            result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)

        baseline = perf_api.get_baseline_of_result(result_tcp)
        baseline = perfrepo_baseline_to_dict(baseline)

        client_opts["testname"] = "TCP_STREAM"
        client_opts["netperf_opts"] = nperf_opts

        tcp_res_data = netperf((h1, h1_nic, 0, {"scope": 0}),
                               (h2, h2_nic, 0, {"scope": 0}),
                               client_opts = client_opts, baseline = baseline,
                               timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)

        netperf_result_template(result_tcp, tcp_res_data)
        result_tcp.set_comment(pr_comment)
        perf_api.save_result(result_tcp, official_result)

    if nperf_protocols.find("udp") > -1:
        # prepare PerfRepo result for udp
        result_udp = perf_api.new_result("udp_ipv4_id",
                                         "udp_ipv4_result",
                                         hash_ignore=[
                                             r'kernel_release',
                                             r'redhat_release',
                                             r'interface_ovs\d+\.hwaddr'])
        result_udp.add_tag(product_name)
示例#6
0
            result_tcp.set_parameter('num_parallel', nperf_num_parallel)

        if nperf_msg_size is not None:
            result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)

        baseline = perf_api.get_baseline_of_result(result_tcp)
        baseline = perfrepo_baseline_to_dict(baseline)

        client_opts["testname"] = "TCP_STREAM"
        client_opts["netperf_opts"] = nperf_opts

        tcp_res_data = netperf(
            (m1, test_if1, 0, {
                "scope": 0
            }), (m2, test_if2, 0, {
                "scope": 0
            }),
            client_opts=client_opts,
            baseline=baseline,
            timeout=(netperf_duration + nperf_reserve) * nperf_max_runs)

        netperf_result_template(result_tcp, tcp_res_data)
        result_tcp.set_comment(pr_comment)
        perf_api.save_result(result_tcp, official_result)

    if nperf_protocols.find("udp") > -1:
        # prepare PerfRepo result for udp
        result_udp = perf_api.new_result(
            "udp_ipv4_id",
            "udp_ipv4_result",
            hash_ignore=[
示例#7
0
    result_tcp.add_tag(product_name)
    if nperf_num_parallel > 1:
        result_tcp.add_tag("multithreaded")
        result_tcp.set_parameter('num_parallel', nperf_num_parallel)

    baseline = perf_api.get_baseline_of_result(result_tcp)
    baseline = perfrepo_baseline_to_dict(baseline)

    tcp_res_data = netperf(
        (guest1, g1_nic, 0), (guest3, g3_nic, 0),
        client_opts={
            "duration": netperf_duration,
            "testname": "TCP_STREAM",
            "confidence": nperf_confidence,
            "num_parallel": nperf_num_parallel,
            "cpu_util": nperf_cpu_util,
            "runs": nperf_max_runs,
            "netperf_opts": nperf_opts,
            "debug": nperf_debug,
            "max_deviation": nperf_max_dev
        },
        baseline=baseline,
        timeout=(netperf_duration + nperf_reserve) * nperf_max_runs)

    netperf_result_template(result_tcp, tcp_res_data)
    result_tcp.set_comment(pr_comment)
    perf_api.save_result(result_tcp)

    # prepare PerfRepo result for udp
    result_udp = perf_api.new_result("udp_ipv4_id",
                                     "udp_ipv4_result",
示例#8
0
        result_tcp.add_tag(product_name)
        if nperf_num_parallel > 1:
            result_tcp.add_tag("multithreaded")
            result_tcp.set_parameter('num_parallel', nperf_num_parallel)

        if nperf_msg_size is not None:
            result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)

        baseline = perf_api.get_baseline_of_result(result_tcp)
        baseline = perfrepo_baseline_to_dict(baseline)

        client_opts["testname"] = "TCP_STREAM"
        client_opts["netperf_opts"] = nperf_opts

        tcp_res_data = netperf((m1, test_if1, 0, {"scope": 0}),
                               (m2, test_if2, 0, {"scope": 0}),
                               client_opts = client_opts, baseline = baseline,
                               timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)

        netperf_result_template(result_tcp, tcp_res_data)
        result_tcp.set_comment(pr_comment)
        perf_api.save_result(result_tcp, official_result)

    if nperf_protocols.find("udp") > -1:
        # prepare PerfRepo result for udp
        result_udp = perf_api.new_result("udp_ipv4_id",
                                         "udp_ipv4_result",
                                         hash_ignore=[
                                             r'kernel_release',
                                             r'redhat_release',
                                             r'testmachine\d+\.interface_tap\d+.hwaddr',
                                             r'guest\d+\.hostname',
示例#9
0
        result_tcp.add_tag(product_name)
        if nperf_num_parallel > 1:
            result_tcp.add_tag("multithreaded")
            result_tcp.set_parameter('num_parallel', nperf_num_parallel)

        if nperf_msg_size is not None:
            result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)

        baseline = perf_api.get_baseline_of_result(result_tcp)
        baseline = perfrepo_baseline_to_dict(baseline)

        client_opts["testname"] = "TCP_STREAM"
        client_opts["netperf_opts"] = nperf_opts

        tcp_res_data = netperf((guest1, g1_nic, 0), (guest3, g3_nic, 0),
                               client_opts = client_opts, baseline = baseline,
                               timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)

        netperf_result_template(result_tcp, tcp_res_data)
        result_tcp.set_comment(pr_comment)
        perf_api.save_result(result_tcp, official_result)

    if nperf_protocols.find("udp") > -1:
        # prepare PerfRepo result for udp
        result_udp = perf_api.new_result("udp_ipv4_id",
                                         "udp_ipv4_result",
                                         hash_ignore=[
                                             r'kernel_release',
                                             r'redhat_release',
                                             r'test_host\d+\.hostname',
                                             r'test_host\d+\..*hwaddr',
示例#10
0
                                         r'machine_h\d+\..*tap\d*\.hwaddr',
                                         r'machine_h\d+\..*tap\d*\.devname'])
    result_tcp.add_tag(product_name)
    if nperf_num_parallel > 1:
        result_tcp.add_tag("multithreaded")
        result_tcp.set_parameter('num_parallel', nperf_num_parallel)

    baseline = perf_api.get_baseline_of_result(result_tcp)
    baseline = perfrepo_baseline_to_dict(baseline)

    tcp_res_data = netperf((guest1, g1_nic, 0), (guest3, g3_nic, 0),
                           client_opts={"duration" : netperf_duration,
                                        "testname" : "TCP_STREAM",
                                        "confidence" : nperf_confidence,
                                        "num_parallel" : nperf_num_parallel,
                                        "cpu_util" : nperf_cpu_util,
                                        "runs": nperf_max_runs,
                                        "netperf_opts": nperf_opts,
                                        "debug": nperf_debug,
                                        "max_deviation": nperf_max_dev},
                           baseline = baseline,
                           timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)

    netperf_result_template(result_tcp, tcp_res_data)
    result_tcp.set_comment(pr_comment)
    perf_api.save_result(result_tcp)

    # prepare PerfRepo result for udp
    result_udp = perf_api.new_result("udp_ipv4_id",
                                     "udp_ipv4_result",
                                     hash_ignore=[
                                         r'kernel_release',