test suite reviews and discussions
 help / color / Atom feed
* [dts] [PATCH V3 0/4] power_branch_ratio: upload suite test plan and script
@ 2020-05-25  2:22 yufengmx
  2020-05-25  2:22 ` [dts] [PATCH V3 1/4] conf/power_branch_ratio: virtual machine configuration yufengmx
                   ` (4 more replies)
  0 siblings, 5 replies; 7+ messages in thread
From: yufengmx @ 2020-05-25  2:22 UTC (permalink / raw)
  To: dts, lei.a.yao; +Cc: yufengmx

 Based on the branch ratio info offered by CPU, the DPDK user can know if 
 the CPU's real workload is high or Low. Then the host server can adjust the 
 related CPU frequency base this indicator. 

v3: 
 -  update test plan and script. 
 -  add compile switch description 
 -  change power driver intel_pstate from disable to enable. 
 -  add more branch ratio information output description. 

v2: 
 -  python3 support. 
 -  use pktgen new callback function to take the place of shell script query. 
 -  display dpdk version. 
 -  remove un-used parameters. 
 -  update comment. 

yufengmx (4):
  conf/power_branch_ratio: virtual machine configuration
  test_plans/power_branch_ratio: add test plan index
  test_plans/power_branch_ratio: upload test plan
  tests/power_branch_ratio: upload automation script

 conf/power_branch_ratio.cfg                 |  30 +
 test_plans/index.rst                        |   1 +
 test_plans/power_branch_ratio_test_plan.rst | 178 +++++
 tests/TestSuite_power_branch_ratio.py       | 679 ++++++++++++++++++++
 4 files changed, 888 insertions(+)
 create mode 100644 conf/power_branch_ratio.cfg
 create mode 100644 test_plans/power_branch_ratio_test_plan.rst
 create mode 100644 tests/TestSuite_power_branch_ratio.py

-- 
2.21.0


^ permalink raw reply	[flat|nested] 7+ messages in thread

* [dts] [PATCH V3 1/4] conf/power_branch_ratio: virtual machine configuration
  2020-05-25  2:22 [dts] [PATCH V3 0/4] power_branch_ratio: upload suite test plan and script yufengmx
@ 2020-05-25  2:22 ` yufengmx
  2020-05-26  2:15   ` Yao, Lei A
  2020-05-25  2:22 ` [dts] [PATCH V3 2/4] test_plans/power_branch_ratio: add test plan index yufengmx
                   ` (3 subsequent siblings)
  4 siblings, 1 reply; 7+ messages in thread
From: yufengmx @ 2020-05-25  2:22 UTC (permalink / raw)
  To: dts, lei.a.yao; +Cc: yufengmx


Based on the branch ratio info offered by CPU, the DPDK user can know if
the CPU's real workload is high or Low. Then the host server can adjust the
related CPU frequency base this indicator.

Signed-off-by: yufengmx <yufengx.mo@intel.com>
---
 conf/power_branch_ratio.cfg | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 conf/power_branch_ratio.cfg

diff --git a/conf/power_branch_ratio.cfg b/conf/power_branch_ratio.cfg
new file mode 100644
index 0000000..bb4af67
--- /dev/null
+++ b/conf/power_branch_ratio.cfg
@@ -0,0 +1,30 @@
+# libvirtd options:
+# [VM name] section value is the name for VM
+# cpu       # hard code type to host-passthrough
+#   number: number of vcpus
+#   cpupin: host cpu list
+# mem
+#   size: 4096
+# disk
+#   file: absolute path to disk image
+#   type: disk image format
+# login
+#   user: user name to login into VM
+#   password: passwork to login into VM
+# device
+#   pf_idx: pass-through device index of DUT ports
+#   guestpci: hardcode value of guest pci address
+# virtio_serial_channel
+#   path: virtio unix socket absolute path
+#   name: virtio serial name in VM
+
+# vm configuration for vm power management case
+[vm0]
+cpu =
+    number=8,cpupin=1 2 3 4 5 6 7 8;
+mem =
+    size=12196;
+disk =
+    file=/home/image/xxxxx.img,opt_format=qcow2;
+login =
+    user=root,password=tester;
-- 
2.21.0


^ permalink raw reply	[flat|nested] 7+ messages in thread

* [dts] [PATCH V3 2/4] test_plans/power_branch_ratio: add test plan index
  2020-05-25  2:22 [dts] [PATCH V3 0/4] power_branch_ratio: upload suite test plan and script yufengmx
  2020-05-25  2:22 ` [dts] [PATCH V3 1/4] conf/power_branch_ratio: virtual machine configuration yufengmx
@ 2020-05-25  2:22 ` yufengmx
  2020-05-25  2:22 ` [dts] [PATCH V3 3/4] test_plans/power_branch_ratio: upload test plan yufengmx
                   ` (2 subsequent siblings)
  4 siblings, 0 replies; 7+ messages in thread
From: yufengmx @ 2020-05-25  2:22 UTC (permalink / raw)
  To: dts, lei.a.yao; +Cc: yufengmx


Based on the branch ratio info offered by CPU, the DPDK user can know if
the CPU's real workload is high or Low. Then the host server can adjust the
related CPU frequency base this indicator.

Signed-off-by: yufengmx <yufengx.mo@intel.com>
---
 test_plans/index.rst | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test_plans/index.rst b/test_plans/index.rst
index 132e957..07797a1 100644
--- a/test_plans/index.rst
+++ b/test_plans/index.rst
@@ -168,6 +168,7 @@ The following are the test plans for the DPDK DTS automated test system.
     vm_power_manager_test_plan
     vm_pw_mgmt_policy_test_plan
     power_bidirection_channel_test_plan
+    power_branch_ratio_test_plan
     power_empty_poll_test_plan
     power_pbf_test_plan
     power_pstate_test_plan
-- 
2.21.0


^ permalink raw reply	[flat|nested] 7+ messages in thread

* [dts] [PATCH V3 3/4] test_plans/power_branch_ratio: upload test plan
  2020-05-25  2:22 [dts] [PATCH V3 0/4] power_branch_ratio: upload suite test plan and script yufengmx
  2020-05-25  2:22 ` [dts] [PATCH V3 1/4] conf/power_branch_ratio: virtual machine configuration yufengmx
  2020-05-25  2:22 ` [dts] [PATCH V3 2/4] test_plans/power_branch_ratio: add test plan index yufengmx
@ 2020-05-25  2:22 ` yufengmx
  2020-05-25  2:22 ` [dts] [PATCH V3 4/4] tests/power_branch_ratio: upload automation script yufengmx
  2020-06-01  3:12 ` [dts] [PATCH V3 0/4] power_branch_ratio: upload suite test plan and script Tu, Lijuan
  4 siblings, 0 replies; 7+ messages in thread
From: yufengmx @ 2020-05-25  2:22 UTC (permalink / raw)
  To: dts, lei.a.yao; +Cc: yufengmx


Based on the branch ratio info offered by CPU, the DPDK user can know if
the CPU's real workload is high or Low. Then the host server can adjust the
related CPU frequency base this indicator.

Signed-off-by: yufengmx <yufengx.mo@intel.com>
---
 test_plans/power_branch_ratio_test_plan.rst | 178 ++++++++++++++++++++
 1 file changed, 178 insertions(+)
 create mode 100644 test_plans/power_branch_ratio_test_plan.rst

diff --git a/test_plans/power_branch_ratio_test_plan.rst b/test_plans/power_branch_ratio_test_plan.rst
new file mode 100644
index 0000000..e9a4a69
--- /dev/null
+++ b/test_plans/power_branch_ratio_test_plan.rst
@@ -0,0 +1,178 @@
+.. Copyright (c) <2010-2020>, Intel Corporation
+   All rights reserved.
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions
+   are met:
+
+   - Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer.
+
+   - Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in
+     the documentation and/or other materials provided with the
+     distribution.
+
+   - Neither the name of Intel Corporation nor the names of its
+     contributors may be used to endorse or promote products derived
+     from this software without specific prior written permission.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+   FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+   COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+   INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+   HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+   STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+   OF THE POSSIBILITY OF SUCH DAMAGE.
+  
+========================================
+Power Policy Based on Branch Ratio Tests
+========================================
+Based on the branch ratio info offered by CPU, the DPDK user can know if
+the CPU's real workload is high or Low. Then the host server can adjust the
+related CPU frequency base this indicator.
+
+
+Prepare work
+============
+1. Turn on Speedstep option in BIOS.
+2. Turn off Hardware Power(HWP disable).
+3. Turn on Turbo in BIOS.
+4. Enable intel_pstate in Linux kernel command::
+
+    intel_pstate=enable
+
+5. Set CONFIG_RTE_LIBRTE_POWER_DEBUG=y CONFIG_RTE_LIBRTE_POWER=y in /config/common_base file.
+6. modprobe msr module to let the application can get the CPU HW info.
+7. Let user space can control the CPU frequency::
+
+    cpupower frequency-set -g userspace
+
+8. Prepare a valid VM using libvirt, 8 virtio-serial channel should be add as
+configuration channel, vCPU and physical CPU mapping table should be configured.
+The configuration part in libvirt is following::
+
+      <cputune>
+        <vcpupin vcpu='0' cpuset='0'/>
+        <vcpupin vcpu='1' cpuset='1'/>
+        <vcpupin vcpu='2' cpuset='2'/>
+        <vcpupin vcpu='3' cpuset='3'/>
+        <vcpupin vcpu='4' cpuset='4'/>
+        <vcpupin vcpu='5' cpuset='5'/>
+        <vcpupin vcpu='6' cpuset='6'/>
+        <vcpupin vcpu='7' cpuset='7'/>
+      </cputune>
+          <channel type='unix'>
+          <source mode='bind' path='/tmp/powermonitor/ubuntu.0'/>
+          <target type='virtio' name='virtio.serial.port.poweragent.0'/>
+          <address type='virtio-serial' controller='0' bus='0' port='1'/>
+        </channel>
+          <channel type='unix'>
+          <source mode='bind' path='/tmp/powermonitor/ubuntu.1'/>
+          <target type='virtio' name='virtio.serial.port.poweragent.1'/>
+          <address type='virtio-serial' controller='0' bus='0' port='2'/>
+        </channel>
+          <channel type='unix'>
+          <source mode='bind' path='/tmp/powermonitor/ubuntu.2'/>
+          <target type='virtio' name='virtio.serial.port.poweragent.2'/>
+          <address type='virtio-serial' controller='0' bus='0' port='3'/>
+        </channel>
+          <channel type='unix'>
+          <source mode='bind' path='/tmp/powermonitor/ubuntu.3'/>
+          <target type='virtio' name='virtio.serial.port.poweragent.3'/>
+          <address type='virtio-serial' controller='0' bus='0' port='4'/>
+        </channel>
+          <channel type='unix'>
+          <source mode='bind' path='/tmp/powermonitor/ubuntu.4'/>
+          <target type='virtio' name='virtio.serial.port.poweragent.4'/>
+          <address type='virtio-serial' controller='0' bus='0' port='5'/>
+        </channel>
+           <channel type='unix'>ak
+          <source mode='bind' path='/tmp/powermonitor/ubuntu.5'/>
+          <target type='virtio' name='virtio.serial.port.poweragent.5'/>
+          <address type='virtio-serial' controller='0' bus='0' port='6'/>
+        </channel>
+           <channel type='unix'>
+          <source mode='bind' path='/tmp/powermonitor/ubuntu.6'/>
+          <target type='virtio' name='virtio.serial.port.poweragent.6'/>
+          <address type='virtio-serial' controller='0' bus='0' port='7'/>
+        </channel>
+          <channel type='unix'>
+          <source mode='bind' path='/tmp/powermonitor/ubuntu.7'/>
+          <target type='virtio' name='virtio.serial.port.poweragent.7'/>
+          <address type='virtio-serial' controller='0' bus='0' port='8'/>
+        </channel>
+
+
+sys_min=/sys/devices/system/cpu/cpu{}/cpufreq/cpuinfo_min_freq
+sys_max=/sys/devices/system/cpu/cpu{}/cpufreq/cpuinfo_max_freq
+
+no_turbo_max=$(rdmsr -p 1 0x0CE -f 15:8 -d)00000
+
+cur_min=sys/devices/system/cpu/cpu{}/cpufreq/scaling_min_freq
+cur_max=sys/devices/system/cpu/cpu{}/cpufreq/scaling_max_freq
+
+Test Case 1 : Basic Branch-Ratio Test based on one NIC pass-through into VM Scenario
+====================================================================================
+1. Launch VM by using libvirt, one NIC should be configured as PCI
+pass-throughput to the VM::
+
+   virsh start [VM name]
+
+2. Launch VM power manager sample on the host to monitor the channel from VM::
+
+    ./examples/vm_power_manager/build/vm_power_mgr -l 12-14 -n 4 --no-pci
+    
+    >add_vm [vm name]
+    >add_channels [vm name] all 
+    >set_channel_status [vm name] all enabled
+    >show_vm [vm name]
+
+3. In the VM, launch guest_vm_power_mgr to set and send the power manager policy
+to the host power sample, the policy is set to BRANCH_RATIO, the default
+BRANCH_RATIO threshold is 0.25::
+
+    ./examples/vm_power_manager/guest_cli/build/guest_vm_power_mgr -c 0xff -n 4 -m 1024 --no-pci --file-prefix=yaolei -- --vm-name=[vm name] --policy=BRANCH_RATIO --vcpu-list=0-7
+    > send_policy now
+
+4. Bind one NIC to DPDK driver in VM, launch testpmd with fwd io mode::
+
+    ./x86_64-native-linuxapp-gcc/app/testpmd -l 0-1 -n 4 -m 1024 --file-prefix=test2 -- -i
+    > start
+
+5. Inject packet with packet generator to the NIC, with line rate(For example),
+check the branch ratio and the related CPU frequency, in this case, the
+core 1 will be used by testpmd as worker core, branch ratio will be shown as
+following in vm_power_mgr's log output::
+
+    1: 0.0048 {250065} {20001}
+    0: 0.0307 {35782} {20000}
+    1: 0.0042 {259798} {0}
+    1: 0.0045 {242642} {20001}
+
+6. [Check Point]Inject packets with packet generator with Line Rate(10G), check
+the core 1 frequency use following cmd, The Frequency reported should be at the
+highest frequency::
+
+   [no_turbo_max]: cur_min=cur_max=no_turbo_max 
+   cat /sys/devices/system/cpu/cpu2/cpufreq/cpuinfo_cur_freq
+
+7. [Check Point]Stopped the traffic from packet generator. Check the core 1
+frequency again, the Frequency reported should be::
+
+    [sys_min]:cur_min=cur_max=sys_min
+
+
+Test Case 2: Set Branch-Ratio Rate by User
+==========================================
+The same as test case1, the only difference is at step2 2. Launch VM power
+manager sample on the host to monitor the channel from VM, set the branch
+ration at host side::
+
+    ./examples/vm_power_manager/build/vm_power_mgr -l 12-14 -n 4 -m 1024 --no-pci -- --branch-ratio=0.1
+
-- 
2.21.0


^ permalink raw reply	[flat|nested] 7+ messages in thread

* [dts] [PATCH V3 4/4] tests/power_branch_ratio: upload automation script
  2020-05-25  2:22 [dts] [PATCH V3 0/4] power_branch_ratio: upload suite test plan and script yufengmx
                   ` (2 preceding siblings ...)
  2020-05-25  2:22 ` [dts] [PATCH V3 3/4] test_plans/power_branch_ratio: upload test plan yufengmx
@ 2020-05-25  2:22 ` yufengmx
  2020-06-01  3:12 ` [dts] [PATCH V3 0/4] power_branch_ratio: upload suite test plan and script Tu, Lijuan
  4 siblings, 0 replies; 7+ messages in thread
From: yufengmx @ 2020-05-25  2:22 UTC (permalink / raw)
  To: dts, lei.a.yao; +Cc: yufengmx


Based on the branch ratio info offered by CPU, the DPDK user can know if
the CPU's real workload is high or Low. Then the host server can adjust the
related CPU frequency base this indicator.

Signed-off-by: yufengmx <yufengx.mo@intel.com>
---
 tests/TestSuite_power_branch_ratio.py | 679 ++++++++++++++++++++++++++
 1 file changed, 679 insertions(+)
 create mode 100644 tests/TestSuite_power_branch_ratio.py

diff --git a/tests/TestSuite_power_branch_ratio.py b/tests/TestSuite_power_branch_ratio.py
new file mode 100644
index 0000000..e055b03
--- /dev/null
+++ b/tests/TestSuite_power_branch_ratio.py
@@ -0,0 +1,679 @@
+# BSD LICENSE
+#
+# Copyright(c) 2010-2020 Intel Corporation. All rights reserved.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+#   * Redistributions of source code must retain the above copyright
+#     notice, this list of conditions and the following disclaimer.
+#   * Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions and the following disclaimer in
+#     the documentation and/or other materials provided with the
+#     distribution.
+#   * Neither the name of Intel Corporation nor the names of its
+#     contributors may be used to endorse or promote products derived
+#     from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""
+DPDK Test suite.
+virtual power manager policy branch ratio test suite.
+"""
+import os
+import re
+import time
+from contextlib import contextmanager
+from copy import deepcopy
+from pprint import pformat
+import traceback
+
+
+from utils import create_mask as dts_create_mask
+from qemu_libvirt import LibvirtKvm
+from pktgen import TRANSMIT_CONT
+from exception import VerifyFailure
+from settings import HEADER_SIZE
+from packet import Packet
+from test_case import TestCase
+
+
+class TestPowerBranchRatio(TestCase):
+    BRANCH_RATIO = "BRANCH_RATIO"
+    vm_name = 'vm0'
+    vm_max_ch = 8
+
+    @property
+    def target_dir(self):
+        target_dir = '/root' + self.dut.base_dir[1:] \
+                     if self.dut.base_dir.startswith('~') else \
+                     self.dut.base_dir
+        return target_dir
+
+    def get_cores_mask(self, config='all', crb=None):
+        _crb = crb if crb else self.dut
+        ports_socket = 0 if crb else _crb.get_numa_id(_crb.get_ports()[0])
+        mask = dts_create_mask(_crb.get_core_list(config, socket=ports_socket))
+        return mask
+
+    def prepare_binary(self, name, host_crb=None):
+        _host_crb = host_crb if host_crb else self.dut
+        example_dir = "examples/" + name
+        out = _host_crb.build_dpdk_apps('./' + example_dir)
+        self.verify("Error" not in out, "Compilation error")
+        self.verify("No such" not in out, "Compilation error")
+        binary_dir = os.path.join(self.target_dir, example_dir, 'build')
+        cmd = ["ls -F {0} | grep --color=never '*'".format(binary_dir), '# ', 5]
+        exec_file = self.execute_cmds(cmd, name=_host_crb.session.name)
+        binary_file = os.path.join(binary_dir, exec_file[:-1])
+        return binary_file
+
+    def add_console(self, session):
+        self.ext_con[session.name] = [
+            session.send_expect,
+            session.session.get_output_all]
+
+    def get_console(self, name):
+        default_con_table = {
+            self.dut.session.name: [
+                self.dut.send_expect,
+                self.dut.get_session_output],
+            self.dut.alt_session.name: [
+                self.dut.alt_session.send_expect,
+                self.dut.alt_session.session.get_output_all]}
+        if name not in default_con_table:
+            return self.ext_con.get(name) or [None, None]
+        else:
+            return default_con_table.get(name)
+
+    def execute_cmds(self, cmds, name='dut'):
+        if len(cmds) == 0:
+            return
+        if isinstance(cmds, str):
+            cmds = [cmds, '# ', 5]
+        if not isinstance(cmds[0], list):
+            cmds = [cmds]
+        outputs = [] if len(cmds) > 1 else ''
+        console, msg_pipe = self.get_console(name)
+        if not console or not msg_pipe:
+            return
+        for item in cmds:
+            try:
+                expected_str = item[1] or '# '
+                timeout = int(item[2]) if len(item) == 3 else 5
+                output = console(item[0], expected_str, timeout)
+            except Exception as e:
+                msg = "execute '{0}' timeout".format(item[0])
+                raise Exception(msg)
+            time.sleep(0.5)
+            if len(cmds) > 1:
+                outputs.append(output)
+            else:
+                outputs = output
+
+        return outputs
+
+    def d_con(self, cmds):
+        return self.execute_cmds(cmds, name=self.dut.session.name)
+
+    def d_a_con(self, cmds):
+        return self.execute_cmds(cmds, name=self.dut.alt_session.name)
+
+    def vm_con(self, cmds):
+        return self.execute_cmds(cmds, name=self.vm_dut.session.name)
+
+    def vm_g_con(self, cmds):
+        return self.execute_cmds(cmds, name=self.guest_con_name)
+
+    def get_pkt_len(self, pkt_type, frame_size=1024):
+        headers_size = sum([HEADER_SIZE[x] for x in ['eth', 'ip', pkt_type]])
+        pktlen = frame_size - headers_size
+        return pktlen
+
+    def config_stream(self, dut_port_id, stm_name):
+        dmac = self.dut.get_mac_address(dut_port_id)
+        # set streams for traffic
+        pkt_name = 'udp'
+        pkt_configs = {
+            'UDP_1': {
+                'type': pkt_name.upper(),
+                'pkt_layers': {
+                    'ether': {'dst': dmac},
+                    'raw': {'payload': ['58'] * self.get_pkt_len(pkt_name)}}},
+        }
+        # create packet for send
+        if stm_name not in list(pkt_configs.keys()):
+            msg = '{} not set'.format(stm_name)
+            raise VerifyFailure(msg)
+        values = pkt_configs[stm_name]
+        pkt_type = values.get('type')
+        pkt_layers = values.get('pkt_layers')
+        pkt = Packet(pkt_type=pkt_type)
+        for layer in list(pkt_layers.keys()):
+            pkt.config_layer(layer, pkt_layers[layer])
+        return pkt.pktgen.pkt
+
+    def add_stream_to_pktgen(self, txport, rxport, send_pkts, option):
+        stream_ids = []
+        _option = deepcopy(option)
+        _option['pcap'] = send_pkts[0]
+        stream_id = self.tester.pktgen.add_stream(txport, rxport, send_pkts[0])
+        self.tester.pktgen.config_stream(stream_id, _option)
+        stream_ids.append(stream_id)
+        _option = deepcopy(option)
+        _option['pcap'] = send_pkts[1]
+        stream_id = self.tester.pktgen.add_stream(rxport, txport, send_pkts[1])
+        self.tester.pktgen.config_stream(stream_id, _option)
+        stream_ids.append(stream_id)
+        return stream_ids
+
+    def traffic(self, option):
+        txport = option.get('tx_intf')
+        rxport = option.get('rx_intf')
+        rate_percent = option.get('rate_percent', float(100))
+        duration = option.get('duration', 15)
+        send_pkts = option.get('stream') or []
+        # clear streams before add new streams
+        self.tester.pktgen.clear_streams()
+        # set stream into pktgen
+        s_option = {
+            'stream_config': {
+                'txmode': {},
+                'transmit_mode': TRANSMIT_CONT,
+                'rate': rate_percent, }
+        }
+        stream_ids = self.add_stream_to_pktgen(
+            txport, rxport, send_pkts, s_option)
+        # traffic options
+        traffic_opt = {
+            'method': 'throughput',
+            'callback': self.query_cpu_freq,
+            'interval': duration - 2,
+            'duration': duration, }
+        result = self.tester.pktgen.measure(stream_ids, traffic_opt)
+
+        return result
+
+    def run_traffic(self, option):
+        tester_tx_port_id = self.tester.get_local_port(self.dut_ports[0])
+        tester_rx_port_id = self.tester.get_local_port(self.dut_ports[1])
+        stm_type = option.get('stm_type')
+        duration = option.get('duration', None) or 15
+        ports_topo = {
+            'tx_intf': tester_tx_port_id,
+            'rx_intf': tester_rx_port_id,
+            'stream': [
+                self.config_stream(self.dut_ports[0], stm_type),
+                self.config_stream(self.dut_ports[1], stm_type), ],
+            'duration': duration, }
+        result = self.traffic(ports_topo)
+
+        return result
+
+    def create_powermonitor_folder(self):
+        # create temporary folder for power monitor
+        cmd = 'mkdir -p {0}; chmod 777 {0}'.format(self.vm_log_dir)
+        self.d_a_con(cmd)
+
+    def init_vms_params(self):
+        self.vcpu_map = self.vm = self.vm_dut = self.guest_session = None
+        self.vm_log_dir = '/tmp/powermonitor'
+        self.create_powermonitor_folder()
+
+    def add_pf_device(self, pci_addr, vm_inst):
+        vm_params = {
+            'driver': 'pci-assign',
+            'driver': 'vfio',
+            'opt_host': pci_addr,
+            'guestpci':  '0000:00:07.0'}
+        vm_inst.set_vm_device(**vm_params)
+
+    def start_vm(self):
+        '''
+        '''
+        # set vm initialize parameters
+        self.init_vms_params()
+        # start vm
+        self.vm = LibvirtKvm(self.dut, self.vm_name, self.suite_name)
+        # pass pf to virtual machine
+        pci_addr = self.dut.get_port_pci(self.dut_ports[0])
+        self.add_pf_device(pci_addr, self.vm)
+        # add channel
+        ch_name = 'virtio.serial.port.poweragent.{0}'
+        vm_path = os.path.join(self.vm_log_dir, '{0}.{1}')
+        for cnt in range(self.vm_max_ch):
+            channel = {
+                'path': vm_path.format(self.vm_name, cnt),
+                'name': ch_name.format(cnt)}
+            self.vm.add_vm_virtio_serial_channel(**channel)
+        # set vm default driver
+        self.vm.def_driver = 'igb_uio'
+        # boot up vm
+        self.vm_dut = self.vm.start()
+        self.is_vm_on = True
+        self.verify(self.vm_dut, "create vm_dut fail !")
+        self.add_console(self.vm_dut.session)
+        # get virtual machine cpu cores
+        self.vcpu_map = self.vm.get_vm_cpu()
+
+    def close_vm(self):
+        '''
+        '''
+        if not self.is_vm_on:
+            return
+        if self.guest_session:
+            self.vm_dut.close_session(self.guest_session)
+        self.vm.stop()
+        self.vm = None
+        self.is_vm_on = False
+        self.dut.virt_exit()
+        cmd_fmt = 'virsh {0} {1} > /dev/null 2>&1'.format
+        cmds = [
+            [cmd_fmt('shutdown', self.vm_name), '# '],
+            [cmd_fmt('undefine', self.vm_name), '# '], ]
+        self.d_a_con(cmds)
+
+    def preset_compilation(self):
+        '''
+        '''
+        sw_table = [
+            "CONFIG_RTE_LIBRTE_POWER",
+            "CONFIG_RTE_LIBRTE_POWER_DEBUG",
+        ]
+        for sw in sw_table:
+            cmd = ("sed -i -e "
+                   "'s/{0}=n$/{0}=y/' "
+                   "{1}/config/common_base").format(sw, self.target_dir)
+            self.d_a_con(cmd)
+        # re-compile dpdk source code
+        self.dut.build_install_dpdk(self.target)
+
+    @contextmanager
+    def restore_compilation(self):
+        try:
+            yield
+        finally:
+            sw_table = [
+                "CONFIG_RTE_LIBRTE_POWER",
+                "CONFIG_RTE_LIBRTE_POWER_DEBUG",
+            ]
+            for sw in sw_table:
+                cmd = ("sed -i -e "
+                       "'s/{0}=y$/{0}=n/' "
+                       "{1}/config/common_base").format(sw, self.target_dir)
+                self.d_a_con(cmd)
+            # re-compile dpdk source code
+            self.dut.build_install_dpdk(self.target)
+
+    def init_vm_power_mgr(self):
+        self.vm_power_mgr = self.prepare_binary('vm_power_manager')
+
+    def start_vm_power_mgr(self):
+        sub_option = (
+            '-v '
+            '-c {core_mask} '
+            '-n {mem_channel} '
+            '-m {memory_size} '
+            '--no-pci ').format(**{
+                'core_mask': self.get_cores_mask("1S/3C/1T"),
+                'mem_channel': self.dut.get_memory_channels(),
+                'memory_size': 1024, })
+        prompt = 'vmpower>'
+        option = sub_option + \
+            (' -- --branch-ratio={}'.format(self.branch_ratio) \
+            if self.branch_ratio else '')
+        cmd = [' '.join([self.vm_power_mgr, option]), prompt, 50]
+        self.d_con(cmd)
+        self.is_mgr_on = True
+
+    def set_vm_power_mgr(self):
+        vm_name = self.vm_name
+        cmds = [
+            "add_vm %s" % vm_name,
+            "add_channels %s all" % vm_name,
+            'set_channel_status %s all enabled' % vm_name,
+            "show_vm %s" % vm_name]
+        prompt = 'vmpower>'
+        self.d_con([[cmd, prompt] for cmd in cmds])
+
+    def close_vm_power_mgr(self):
+        if not self.is_mgr_on:
+            return
+        self.d_con(['quit', '# ', 30])
+        self.is_mgr_on = False
+
+    def init_guest_mgr(self):
+        name = 'vm_power_manager/guest_cli'
+        self.guest_cli = self.prepare_binary(name, host_crb=self.vm_dut)
+        self.guest_con_name = \
+            '_'.join([self.vm_dut.NAME, name.replace('/', '-')])
+        self.guest_session = self.vm_dut.create_session(self.guest_con_name)
+        self.add_console(self.guest_session)
+
+    def start_guest_mgr(self):
+        prompt = r"vmpower\(guest\)>"
+        option = (
+            '-v '
+            '-c {core_mask} '
+            '-n {memory_channel} '
+            '-m {memory_size} '
+            '--no-pci '
+            '--file-prefix={file_prefix} '
+            '-- '
+            '--vm-name={vm_name} '
+            '--policy={policy} '
+            '--vcpu-list={vpus} ').format(**{
+                'core_mask': '0xff',
+                'memory_channel': self.vm_dut.get_memory_channels(),
+                'memory_size': 1024,
+                'policy': self.BRANCH_RATIO,
+                'file_prefix': 'vmpower1',
+                'vm_name': self.vm_name,
+                'vpus': ','.join(
+                    [str(int(index) - 1) for index in self.vcpu_map]),
+            })
+        guest_cmd = ' '.join([self.guest_cli, option])
+        self.vm_g_con([guest_cmd, prompt, 120])
+        self.is_guest_on = True
+
+    def send_policy_on_guest_mgr(self):
+        self.vm_g_con(['send_policy now', r"vmpower\(guest\)>", 20])
+
+    def close_guest_mgr(self):
+        if not self.is_guest_on:
+            return
+        self.vm_g_con("quit")
+        self.is_guest_on = False
+
+    def init_vm_testpmd(self):
+        self.vm_testpmd = "{}/{}/app/testpmd".format(
+            self.target_dir, self.dut.target)
+
+    def start_vm_testpmd(self):
+        cores = [0, 1]
+        core_mask = dts_create_mask(cores)
+        option = (
+            '-v '
+            '-c {core_mask} '
+            '-n {mem_channel} '
+            '-m {memsize} '
+            '--file-prefix={file-prefix} '
+            '-- -i ').format(**{
+                'core_mask': core_mask,
+                'mem_channel': self.vm_dut.get_memory_channels(),
+                'memsize': 1024,
+                'file-prefix': 'vmpower2', })
+
+        cmd = ' '.join([self.vm_testpmd, option])
+        self.vm_con([cmd, "testpmd> ", 120])
+        self.is_pmd_on = True
+
+    def set_vm_testpmd(self):
+        cmd = 'start'
+        self.vm_con([cmd, "testpmd> ", 15])
+
+    def close_vm_testpmd(self):
+        if not self.is_pmd_on:
+            return
+        self.vm_con(['quit', '# ', 15])
+        self.is_pmd_on = False
+
+    def get_sys_power_driver(self):
+        drv_file = "/sys/devices/system/cpu/cpu0/cpufreq/scaling_driver"
+        output = self.d_a_con('cat ' + drv_file)
+        if not output:
+            msg = 'unknown power driver'
+            raise VerifyFailure(msg)
+        drv_name = output.splitlines()[0].strip()
+        return drv_name
+
+    def query_cpu_freq(self):
+        cmd = ';'.join([
+            "cat /sys/devices/system/cpu/cpu{0}/cpufreq/scaling_min_freq",
+            "cat /sys/devices/system/cpu/cpu{0}/cpufreq/scaling_max_freq"
+            ]).format(self.check_core)
+        output = self.d_a_con(cmd)
+        if not output:
+            self.scaling_min_freq, self.scaling_max_freq = 0, 0
+        else:
+            values = [int(item) for item in output.splitlines()]
+            self.scaling_min_freq, self.scaling_max_freq = values
+
+    def get_core_scaling_max_freq(self, core_index):
+        cpu_attr = '/sys/devices/system/cpu/cpu{0}/cpufreq/scaling_max_freq'
+        cmd = 'cat ' + cpu_attr.format(core_index)
+        output = self.d_a_con(cmd)
+        return int(output)
+
+    def get_core_scaling_min_freq(self, core_index):
+        cpu_attr = '/sys/devices/system/cpu/cpu{0}/cpufreq/scaling_min_freq'
+        cmd = 'cat ' + cpu_attr.format(core_index)
+        output = self.d_a_con(cmd)
+        return int(output)
+
+    def get_no_turbo_max(self):
+        cmd = 'rdmsr -p {} 0x0CE -f 15:8 -d'.format(self.check_core)
+        output = self.d_a_con(cmd)
+        freq = output.strip() + '00000'
+        return int(freq)
+
+    def get_all_cpu_attrs(self):
+        ''' get all cpus' attribute '''
+        cpu_attrs = ['cpuinfo_max_freq', 'cpuinfo_min_freq']
+        freq = '/sys/devices/system/cpu/cpu{0}/cpufreq/{1}'.format
+        cpu_topos = self.dut.get_all_cores()
+        cpu_info = {}
+        for cpu_topo in cpu_topos:
+            cpu_id = int(cpu_topo['thread'])
+            cpu_info[cpu_id] = {}
+            cpu_info[cpu_id]['socket'] = cpu_topo['socket']
+            cpu_info[cpu_id]['core'] = cpu_topo['core']
+
+        for cpu_attr in cpu_attrs:
+            cmds = []
+            for cpu_id in sorted(cpu_info.keys()):
+                cmds.append('cat {0}'.format(freq(cpu_id, cpu_attr)))
+            output = self.d_a_con(';'.join(cmds))
+            freqs = [int(item) for item in output.splitlines()]
+            for index, cpu_id in enumerate(sorted(cpu_info.keys())):
+                cpu_info[cpu_id][cpu_attr] = freqs[index]
+
+        return cpu_info
+
+    def run_test_pre(self):
+        # boot up binary processes
+        self.start_vm_power_mgr()
+        # set binary process command
+        self.set_vm_power_mgr()
+        # boot up binary processes
+        self.start_guest_mgr()
+        # set binary process command
+        self.send_policy_on_guest_mgr()
+        # boot up binary processes
+        self.start_vm_testpmd()
+        # set binary process command
+        self.set_vm_testpmd()
+
+    def run_test_post(self):
+        # close all binary processes
+        self.close_vm_testpmd()
+        self.close_guest_mgr()
+        self.close_vm_power_mgr()
+
+    def check_core_freq_in_traffic(self, core_index):
+        '''
+        check the cores frequency when running traffic
+             highest frequency[no_turbo_max]: cur_min=cur_max=no_turbo_max
+        '''
+        expected_freq = self.get_no_turbo_max()
+        msg = 'max freq is failed to get.'
+        self.verify(self.scaling_max_freq, msg)
+        msg = 'max freq is not the same as highest frequency <{0}>'
+        self.verify(expected_freq == self.scaling_max_freq,
+                    msg.format(expected_freq))
+        msg = 'min freq is failed to get.'
+        self.verify(self.scaling_min_freq, msg)
+        msg = 'min freq is not the same as highest frequency <{0}>'
+        self.verify(expected_freq == self.scaling_min_freq,
+                    msg.format(expected_freq))
+        msg = "core <{0}> action is ok in traffic".format(core_index)
+        self.logger.info(msg)
+
+    def check_vm_power_mgr_output(self):
+        '''
+        check the branch miss ration and the related CPU frequency, the core
+        used by testpmd as worker core will be shown as branch ratio value.
+        '''
+        output = self.dut.get_session_output(timeout=2)
+        msg = 'virtual machine testpmd has not output message'
+        self.verify(output, msg)
+        pat = '.*\s+(\d+): ([0-9\.]+) \{(\d+)\} \{(\d+)\}.*'
+        core_branch_ratio = re.findall(pat, output)
+        msg = 'virtual machine testpmd has not branch ratio output message'
+        self.verify(core_branch_ratio, msg)
+        self.logger.info(pformat(core_branch_ratio))
+        msg = "branch ratio output is ok"
+        self.logger.info(msg)
+
+    def check_dut_core_freq(self, core_index, ref_freq_name):
+        '''
+        Check the core frequency, the frequency reported should be::
+            [sys_min]: cur_min=cur_max=sys_min
+        '''
+        expected_freq = self.cpu_info.get(core_index, {}).get(ref_freq_name)
+        max_freq = self.get_core_scaling_max_freq(core_index)
+        min_freq = self.get_core_scaling_min_freq(core_index)
+        msg = 'max freq<{0}>/min_freq<{1}>/expected freq<{2}> are not the same'
+        self.verify(
+            max_freq == min_freq and max_freq == expected_freq,
+            msg.format(max_freq, min_freq, expected_freq))
+        msg = "core <{0}> action is ok after traffic stop".format(core_index)
+        self.logger.info(msg)
+
+    def verify_branch_ratio(self):
+        except_content = None
+        msg = "begin test policy <{0}> ...".format(self.BRANCH_RATIO)
+        self.logger.info(msg)
+        try:
+            # prepare testing binary
+            self.run_test_pre()
+            # run traffic
+            option = {'stm_type': 'UDP_1', }
+            self.run_traffic(option)
+            time.sleep(2)
+            # check test result
+            self.check_core_freq_in_traffic(self.check_core)
+            self.check_vm_power_mgr_output()
+            self.check_dut_core_freq(self.check_core, 'cpuinfo_min_freq')
+        except Exception as e:
+            self.logger.error(traceback.format_exc())
+            except_content = e
+        finally:
+            self.run_test_post()
+
+        # check verify result
+        if except_content:
+            raise VerifyFailure(except_content)
+        msg = "test policy <{0}> successful !!!".format(self.BRANCH_RATIO)
+        self.logger.info(msg)
+
+    def verify_power_driver(self):
+        expected_drv = 'intel_pstate'
+        power_drv = self.get_sys_power_driver()
+        msg = "{0} should work with {1} driver on DUT".format(
+            self.suite_name, expected_drv)
+        self.verify(power_drv == expected_drv, msg)
+
+    def check_cpupower_tool(self):
+        cmd = "whereis cpupower > /dev/null 2>&1; echo $?"
+        output = self.d_a_con(cmd)
+        status = True if output and output.strip() == "0" else False
+        msg = 'cpupower tool have not installed on DUT'
+        self.verify(status, msg)
+
+    def init_params(self):
+        self.is_mgr_on = self.is_guest_on = self.is_pmd_on = \
+            self.is_vm_on = None
+        self.ext_con = {}
+        # set branch ratio test value
+        self.branch_ratio = None
+
+    def preset_test_environment(self):
+        self.dut.init_core_list_uncached_linux()
+        self.cpu_info = self.get_all_cpu_attrs()
+        # modprobe msr module to let the application can get the CPU HW info
+        self.d_a_con('modprobe msr')
+        self.d_a_con('cpupower frequency-set -g userspace > /dev/null 2>&1')
+        # compile
+        self.preset_compilation()
+        # boot up vm
+        self.start_vm()
+        # init binary
+        self.init_vm_power_mgr()
+        self.init_vm_testpmd()
+        self.init_guest_mgr()
+        self.check_core = 2
+        msg = "select dut core {} as check core".format(self.check_core)
+        self.logger.info(msg)
+    #
+    # Test cases.
+    #
+
+    def set_up_all(self):
+        """
+        Run at the start of each test suite.
+        """
+        self.init_params()
+        self.dut_ports = self.dut.get_ports(self.nic)
+        self.verify(len(self.dut_ports) >= 1, "Not enough ports")
+        self.check_cpupower_tool()
+        self.verify_power_driver()
+        # prepare testing environment
+        self.preset_test_environment()
+
+    def tear_down_all(self):
+        """
+        Run after each test suite.
+        """
+        with self.restore_compilation():
+            self.close_vm()
+
+    def set_up(self):
+        """
+        Run before each test case.
+        """
+        pass
+
+    def tear_down(self):
+        """
+        Run after each test case.
+        """
+        self.vm_dut.kill_all()
+        self.dut.kill_all()
+
+    def test_perf_basic_branch_ratio(self):
+        """
+        Basic branch-ratio test based on one NIC pass-through into VM scenario
+        """
+        self.branch_ratio = None
+        self.verify_branch_ratio()
+
+    def test_perf_set_branch_ratio_rate_by_user(self):
+        """
+        Set Branch-Ratio Rate by User
+        """
+        self.branch_ratio = 0.1
+        self.verify_branch_ratio()
-- 
2.21.0


^ permalink raw reply	[flat|nested] 7+ messages in thread

* Re: [dts] [PATCH V3 1/4] conf/power_branch_ratio: virtual machine configuration
  2020-05-25  2:22 ` [dts] [PATCH V3 1/4] conf/power_branch_ratio: virtual machine configuration yufengmx
@ 2020-05-26  2:15   ` Yao, Lei A
  0 siblings, 0 replies; 7+ messages in thread
From: Yao, Lei A @ 2020-05-26  2:15 UTC (permalink / raw)
  To: Mo, YufengX, dts



> -----Original Message-----
> From: Mo, YufengX <yufengx.mo@intel.com>
> Sent: Monday, May 25, 2020 10:23 AM
> To: dts@dpdk.org; Yao, Lei A <lei.a.yao@intel.com>
> Cc: Mo, YufengX <yufengx.mo@intel.com>
> Subject: [dts][PATCH V3 1/4] conf/power_branch_ratio: virtual machine
> configuration
> 
> 
> Based on the branch ratio info offered by CPU, the DPDK user can know if
> the CPU's real workload is high or Low. Then the host server can adjust the
> related CPU frequency base this indicator.
> 
> Signed-off-by: yufengmx <yufengx.mo@intel.com>
Reviewed-by: Lei Yao<lei.a.yao@intel.com>
> ---
>  conf/power_branch_ratio.cfg | 30 ++++++++++++++++++++++++++++++
>  1 file changed, 30 insertions(+)
>  create mode 100644 conf/power_branch_ratio.cfg
> 
> diff --git a/conf/power_branch_ratio.cfg b/conf/power_branch_ratio.cfg
> new file mode 100644
> index 0000000..bb4af67
> --- /dev/null
> +++ b/conf/power_branch_ratio.cfg
> @@ -0,0 +1,30 @@
> +# libvirtd options:
> +# [VM name] section value is the name for VM
> +# cpu       # hard code type to host-passthrough
> +#   number: number of vcpus
> +#   cpupin: host cpu list
> +# mem
> +#   size: 4096
> +# disk
> +#   file: absolute path to disk image
> +#   type: disk image format
> +# login
> +#   user: user name to login into VM
> +#   password: passwork to login into VM
> +# device
> +#   pf_idx: pass-through device index of DUT ports
> +#   guestpci: hardcode value of guest pci address
> +# virtio_serial_channel
> +#   path: virtio unix socket absolute path
> +#   name: virtio serial name in VM
> +
> +# vm configuration for vm power management case
> +[vm0]
> +cpu =
> +    number=8,cpupin=1 2 3 4 5 6 7 8;
> +mem =
> +    size=12196;
> +disk =
> +    file=/home/image/xxxxx.img,opt_format=qcow2;
> +login =
> +    user=root,password=tester;
> --
> 2.21.0


^ permalink raw reply	[flat|nested] 7+ messages in thread

* Re: [dts] [PATCH V3 0/4] power_branch_ratio: upload suite test plan and script
  2020-05-25  2:22 [dts] [PATCH V3 0/4] power_branch_ratio: upload suite test plan and script yufengmx
                   ` (3 preceding siblings ...)
  2020-05-25  2:22 ` [dts] [PATCH V3 4/4] tests/power_branch_ratio: upload automation script yufengmx
@ 2020-06-01  3:12 ` Tu, Lijuan
  4 siblings, 0 replies; 7+ messages in thread
From: Tu, Lijuan @ 2020-06-01  3:12 UTC (permalink / raw)
  To: Mo, YufengX, dts, Yao, Lei A; +Cc: Mo, YufengX

Applied the series, thanks

> -----Original Message-----
> From: dts [mailto:dts-bounces@dpdk.org] On Behalf Of yufengmx
> Sent: Monday, May 25, 2020 10:23 AM
> To: dts@dpdk.org; Yao, Lei A <lei.a.yao@intel.com>
> Cc: Mo, YufengX <yufengx.mo@intel.com>
> Subject: [dts] [PATCH V3 0/4] power_branch_ratio: upload suite test plan and
> script
> 
>  Based on the branch ratio info offered by CPU, the DPDK user can know if
> the CPU's real workload is high or Low. Then the host server can adjust the
> related CPU frequency base this indicator.
> 
> v3:
>  -  update test plan and script.
>  -  add compile switch description
>  -  change power driver intel_pstate from disable to enable.
>  -  add more branch ratio information output description.
> 
> v2:
>  -  python3 support.
>  -  use pktgen new callback function to take the place of shell script query.
>  -  display dpdk version.
>  -  remove un-used parameters.
>  -  update comment.
> 
> yufengmx (4):
>   conf/power_branch_ratio: virtual machine configuration
>   test_plans/power_branch_ratio: add test plan index
>   test_plans/power_branch_ratio: upload test plan
>   tests/power_branch_ratio: upload automation script
> 
>  conf/power_branch_ratio.cfg                 |  30 +
>  test_plans/index.rst                        |   1 +
>  test_plans/power_branch_ratio_test_plan.rst | 178 +++++
>  tests/TestSuite_power_branch_ratio.py       | 679 ++++++++++++++++++++
>  4 files changed, 888 insertions(+)
>  create mode 100644 conf/power_branch_ratio.cfg  create mode 100644
> test_plans/power_branch_ratio_test_plan.rst
>  create mode 100644 tests/TestSuite_power_branch_ratio.py
> 
> --
> 2.21.0


^ permalink raw reply	[flat|nested] 7+ messages in thread

end of thread, back to index

Thread overview: 7+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2020-05-25  2:22 [dts] [PATCH V3 0/4] power_branch_ratio: upload suite test plan and script yufengmx
2020-05-25  2:22 ` [dts] [PATCH V3 1/4] conf/power_branch_ratio: virtual machine configuration yufengmx
2020-05-26  2:15   ` Yao, Lei A
2020-05-25  2:22 ` [dts] [PATCH V3 2/4] test_plans/power_branch_ratio: add test plan index yufengmx
2020-05-25  2:22 ` [dts] [PATCH V3 3/4] test_plans/power_branch_ratio: upload test plan yufengmx
2020-05-25  2:22 ` [dts] [PATCH V3 4/4] tests/power_branch_ratio: upload automation script yufengmx
2020-06-01  3:12 ` [dts] [PATCH V3 0/4] power_branch_ratio: upload suite test plan and script Tu, Lijuan

test suite reviews and discussions

Archives are clonable:
	git clone --mirror http://inbox.dpdk.org/dts/0 dts/git/0.git

	# If you have public-inbox 1.1+ installed, you may
	# initialize and index your mirror using the following commands:
	public-inbox-init -V2 dts dts/ http://inbox.dpdk.org/dts \
		dts@dpdk.org
	public-inbox-index dts


Newsgroup available over NNTP:
	nntp://inbox.dpdk.org/inbox.dpdk.dts


AGPL code for this site: git clone https://public-inbox.org/ public-inbox