diff --git a/conf/power_branch_ratio.cfg b/conf/power_branch_ratio.cfg
index d3499ffe..fd4a9b0e 100644
--- a/conf/power_branch_ratio.cfg
+++ b/conf/power_branch_ratio.cfg
@@ -31,3 +31,7 @@ login =
 [suite]
 frame_size = 1024
 check_ratio = 0.3
+from_core = 1
+to_core = 3
+check_core = 2
+testpmd_cores = 1, 2
diff --git a/test_plans/power_branch_ratio_test_plan.rst b/test_plans/power_branch_ratio_test_plan.rst
index e9a4a693..e0142d05 100644
--- a/test_plans/power_branch_ratio_test_plan.rst
+++ b/test_plans/power_branch_ratio_test_plan.rst
@@ -29,7 +29,7 @@
    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
 ========================================
@@ -50,129 +50,36 @@ Prepare work
 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
+
+sys_min=/sys/devices/system/cpu/cpu2/cpufreq/cpuinfo_min_freq
+no_turbo_max=$(rdmsr -p 2 0x0CE -f 15:8 -d)00000
+
+Test Case 1 : Set Branch-Ratio Test Rate by User ====================================================================================
+1. Launch VM power manager sample on the host to run branch monitor.
+./x86_64-native-linuxapp-gcc/examples/dpdk-vm_power_manager  -v -c 0xe -n 1 -m 1024 --no-pci  -- --core-branch-ratio=1-3:0.3
 
-    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
+2. Launch testpmd with fwd io mode::
+./x86_64-native-linuxapp-gcc/app/dpdk-testpmd  -v -c 0x6 -n 1 -m 1024 --file-prefix=vmpower2 -- -i
     > start
 
-5. Inject packet with packet generator to the NIC, with line rate(For example),
+3. Inject packet with packet generator to the NIC, with line rate,
 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
+core 2 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::
+The above values in order are core number, ratio measured , # of branches, number of polls.
 
-   [no_turbo_max]: cur_min=cur_max=no_turbo_max 
-   cat /sys/devices/system/cpu/cpu2/cpufreq/cpuinfo_cur_freq
+4. [Check Point]Inject packets with packet generator with Line Rate(10G), check
+the core 2 frequency use following cmd, The Frequency reported should be at the
+highest frequency::
+cat /sys/devices/system/cpu/cpu2/cpufreq/scaling_cur_freq
+[no_turbo_max]: cur_freq >= no_turbo_max(P1)
 
-7. [Check Point]Stopped the traffic from packet generator. Check the core 1
+5. [Check Point]Stopped the traffic from packet generator. Check the core 2
 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
-
+[sys_min]:cur_freq <= sys_min
diff --git a/tests/TestSuite_power_branch_ratio.py b/tests/TestSuite_power_branch_ratio.py
index ad04b2f8..a157539a 100644
--- a/tests/TestSuite_power_branch_ratio.py
+++ b/tests/TestSuite_power_branch_ratio.py
@@ -55,8 +55,6 @@ from test_case import TestCase
 
 class TestPowerBranchRatio(TestCase):
     BRANCH_RATIO = "BRANCH_RATIO"
-    vm_name = 'vm0'
-    vm_max_ch = 8
 
     @property
     def target_dir(self):
@@ -123,17 +121,17 @@ class TestPowerBranchRatio(TestCase):
 
         return outputs
 
-    def d_con(self, cmds):
-        return self.execute_cmds(cmds, name=self.dut.session.name)
+    def d_con(self, cmd):
+        _cmd = [cmd, '# ', 10] if isinstance(cmd, str) else cmd
+        return self.dut.send_expect(*_cmd)
 
-    def d_a_con(self, cmds):
-        return self.execute_cmds(cmds, name=self.dut.alt_session.name)
+    def d_a_con(self, cmd):
+        _cmd = [cmd, '# ', 10] if isinstance(cmd, str) else cmd
+        return self.dut.alt_session.send_expect(*_cmd)
 
-    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 d_sys_con(self, cmd):
+        _cmd = [cmd, '# ', 10] if isinstance(cmd, str) else cmd
+        return self.alt_sys_session.send_expect(*_cmd)
 
     def get_pkt_len(self, pkt_type, frame_size=1024):
         headers_size = sum([HEADER_SIZE[x] for x in ['eth', 'ip', pkt_type]])
@@ -220,70 +218,6 @@ class TestPowerBranchRatio(TestCase):
 
         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.vcpu_lst = 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 = [int(core) for core in self.vm.get_vm_cpu()]
-        self.vcpu_lst = [int(item['core']) for item  in self.vm_dut.cores]
-
-    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)
-
     @property
     def compile_switch(self):
         sw_table = [
@@ -291,7 +225,7 @@ class TestPowerBranchRatio(TestCase):
             "CONFIG_RTE_LIBRTE_POWER_DEBUG",
         ]
         return sw_table
-    
+
     def preset_compilation(self):
         if 'meson' == load_global_setting(HOST_BUILD_TYPE_SETTING):
             compile_SWs = self.compile_switch + ["CONFIG_RTE_LIBRTE_I40E_PMD"]
@@ -354,77 +288,29 @@ class TestPowerBranchRatio(TestCase):
                 'memory_size': 1024, })
         prompt = 'vmpower>'
         option = sub_option + \
-            (' -- --core-branch-ratio={}'.format(self.branch_ratio) \
+            (' -- --core-branch-ratio={0}-{1}:{2}'.format(self.from_core, self.to_core, 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 add_alternative_session_to_dut(self):
+        self.alt_sys_session = self.dut.create_session("alt_sys_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(index) for index in self.vcpu_lst]),
-            })
-        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 = os.path.join(self.target_dir,
+    def init_testpmd(self):
+        self.testpmd = os.path.join(self.target_dir,
                                        self.dut.apps_name['test-pmd'])
 
-    def start_vm_testpmd(self):
-        cores = [0, 1]
+    def start_testpmd(self):
+        cores = []
+        for core in self.testpmd_cores:
+            cores.append(core)
         core_mask = dts_create_mask(cores)
         option = (
             '-v '
@@ -434,22 +320,22 @@ class TestPowerBranchRatio(TestCase):
             '--file-prefix={file-prefix} '
             '-- -i ').format(**{
                 'core_mask': core_mask,
-                'mem_channel': self.vm_dut.get_memory_channels(),
+                'mem_channel': self.dut.get_memory_channels(),
                 'memsize': 1024,
                 'file-prefix': 'vmpower2', })
 
-        cmd = ' '.join([self.vm_testpmd, option])
-        self.vm_con([cmd, "testpmd> ", 120])
+        cmd = ' '.join([self.testpmd, option])
+        self.d_a_con([cmd, "testpmd> ", 120])
         self.is_pmd_on = True
 
-    def set_vm_testpmd(self):
+    def set_testpmd(self):
         cmd = 'start'
-        self.vm_con([cmd, "testpmd> ", 15])
+        self.d_a_con([cmd, "testpmd> ", 15])
 
-    def close_vm_testpmd(self):
+    def close_testpmd(self):
         if not self.is_pmd_on:
             return
-        self.vm_con(['quit', '# ', 15])
+        self.d_a_con(['quit', '# ', 15])
         self.is_pmd_on = False
 
     def get_sys_power_driver(self):
@@ -463,31 +349,17 @@ class TestPowerBranchRatio(TestCase):
 
     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"
+            "cat /sys/devices/system/cpu/cpu{0}/cpufreq/scaling_cur_freq"
             ]).format(self.check_core)
-        output = self.d_a_con(cmd)
+        output = self.d_sys_con(cmd)
         if not output:
-            self.scaling_min_freq, self.scaling_max_freq = 0, 0
+            self.scaling_cur_freq = 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)
+            self.scaling_cur_freq = round(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)
+        output = self.d_sys_con(cmd)
         freq = output.strip() + '00000'
         return int(freq)
 
@@ -517,41 +389,32 @@ class TestPowerBranchRatio(TestCase):
     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()
+        self.start_testpmd()
         # set binary process command
-        self.set_vm_testpmd()
+        self.set_testpmd()
+
 
     def run_test_post(self):
         # close all binary processes
-        self.close_vm_testpmd()
-        self.close_guest_mgr()
+        self.close_testpmd()
         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
+             highest frequency[no_turbo_max]: expected_freq(P1) <= cur_freq
         '''
         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 = 'failed to get cur freq.'
+        self.verify(self.scaling_cur_freq, msg)
+        msg = 'cur freq <{0}> is lower than expected freq <{1}>'
+        self.verify(expected_freq <= self.scaling_cur_freq,
+                    msg.format(self.scaling_cur_freq ,expected_freq))
         msg = "core <{0}> action is ok in traffic".format(core_index)
         self.logger.info(msg)
+        displayFreqData = "Freqs in Traffic : Check Core Freq {0} >= Expected Freq {1}".format(self.scaling_cur_freq, expected_freq)
+        self.logger.info(displayFreqData)
 
     def check_vm_power_mgr_output(self):
         '''
@@ -569,20 +432,22 @@ class TestPowerBranchRatio(TestCase):
         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 check_core_freq_no_traffic(self, core_index, ref_freq_name):
+            '''
+            Check the core frequency, the frequency reported should be::
+                cur_freq <= sys_min
+            '''
+            expected_freq = self.cpu_info.get(core_index, {}).get(ref_freq_name)
+            self.query_cpu_freq()
+            time.sleep(1)
+            msg = 'cur freq<{0}> is higher than /expected freq<{1}> in no traffic'
+            self.verify(
+                self.scaling_cur_freq <= expected_freq,
+                msg.format(self.scaling_cur_freq, expected_freq))
+            msg = "core <{0}> action is ok after traffic stop".format(core_index)
+            self.logger.info(msg)
+            displayFreqData = "Freqs in NO Traffic: Check Core Freq {0} <= Expected Freq {1}".format(self.scaling_cur_freq, expected_freq)
+            self.logger.info(displayFreqData)
 
     def verify_branch_ratio(self):
         except_content = None
@@ -598,7 +463,7 @@ class TestPowerBranchRatio(TestCase):
             # 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')
+            self.check_core_freq_no_traffic(self.check_core, 'cpuinfo_min_freq')
         except Exception as e:
             self.logger.error(traceback.format_exc())
             except_content = e
@@ -626,8 +491,7 @@ class TestPowerBranchRatio(TestCase):
         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.is_mgr_on = self.is_pmd_on = None
         self.ext_con = {}
         # set branch ratio test value
         self.branch_ratio = None
@@ -640,16 +504,17 @@ class TestPowerBranchRatio(TestCase):
         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.init_testpmd()
+        self.add_alternative_session_to_dut()
         test_content = self.get_suite_cfg()
         self.frame_size = test_content.get('frame_size') or 1024
         self.check_ratio = test_content.get('check_ratio') or 0.1
-        self.check_core = self.vcpu_map[1]
+        self.from_core = test_content.get('from_core')
+        self.to_core = test_content.get('to_core')
+        self.check_core = test_content.get('check_core')
+        self.testpmd_cores = test_content.get('testpmd_cores')
         msg = "select dut core {} as check core".format(self.check_core)
         self.logger.info(msg)
     #
@@ -672,8 +537,7 @@ class TestPowerBranchRatio(TestCase):
         """
         Run after each test suite.
         """
-        with self.restore_environment():
-            self.close_vm()
+        self.restore_environment()
 
     def set_up(self):
         """
@@ -685,16 +549,8 @@ class TestPowerBranchRatio(TestCase):
         """
         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
