From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mga01.intel.com (mga01.intel.com [192.55.52.88]) by dpdk.org (Postfix) with ESMTP id 0FBB02B8D for ; Fri, 16 Jun 2017 06:57:30 +0200 (CEST) Received: from fmsmga002.fm.intel.com ([10.253.24.26]) by fmsmga101.fm.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 15 Jun 2017 21:57:29 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.39,346,1493708400"; d="scan'208";a="1183197438" Received: from unknown (HELO dpdk-fedora20.icx.intel.com) ([10.240.176.135]) by fmsmga002.fm.intel.com with ESMTP; 15 Jun 2017 21:57:29 -0700 From: Lijuan Tu To: dts@dpdk.org Cc: Lijuan Tu Date: Fri, 16 Jun 2017 12:58:50 +0800 Message-Id: <1497589130-7175-2-git-send-email-lijuanx.a.tu@intel.com> X-Mailer: git-send-email 1.9.3 In-Reply-To: <1497589130-7175-1-git-send-email-lijuanx.a.tu@intel.com> References: <1497589130-7175-1-git-send-email-lijuanx.a.tu@intel.com> Subject: [dts] [PATCH V1 2/2] multiple_pthread: Add test script. X-BeenThere: dts@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: test suite reviews and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Fri, 16 Jun 2017 04:57:31 -0000 The script only support Linux OS now. Signed-off-by: Lijuan Tu --- tests/TestSuite_multiple_pthread.py | 379 ++++++++++++++++++++++++++++++++++++ 1 file changed, 379 insertions(+) create mode 100644 tests/TestSuite_multiple_pthread.py diff --git a/tests/TestSuite_multiple_pthread.py b/tests/TestSuite_multiple_pthread.py new file mode 100644 index 0000000..7ebbd0c --- /dev/null +++ b/tests/TestSuite_multiple_pthread.py @@ -0,0 +1,379 @@ +# BSD LICENSE +# +# Copyright(c) 2010-2014 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. + +Test Multiple Pthread Feature + +""" +import utils +import dts +import time +import re +import os +import random +import itertools +from test_case import TestCase +from pmd_output import PmdOutput + + +class TestMultiplePthread(TestCase): + + def set_up_all(self): + """ + Run at the start of each test suite. + """ + self.ports = self.dut.get_ports() + self.portmask = utils.create_mask(self.dut.get_ports(self.nic)) + self.verify(len(self.ports) >= 2, "Insufficient number of ports.") + self.ports_socket = self.dut.get_numa_id(self.ports[0]) + self.pmdout = PmdOutput(self.dut) + + def set_up(self): + """ + Run before each test case. + """ + cores = self.dut.get_core_list('all') + + def get_stats(self, portid): + """ + Get packets number from port statistic. + """ + output = PmdOutput(self.dut) + stats = output.get_pmd_stats(portid) + return stats + + def check_forwarding(self, ports): + for i in range(len(ports)): + if i % 2 == 0: + self.send_packet(ports[i], ports[i + 1]) + self.send_packet(ports[i + 1], ports[i]) + + def send_packet(self, txPort, rxPort): + """ + Send packages according to parameters. + """ + port0_stats = self.get_stats(txPort) + gp0tx_bytes = port0_stats['TX-packets'] + port1_stats = self.get_stats(rxPort) + gp1rx_err = port1_stats['RX-errors'] + gp1rx_bytes = port1_stats['RX-packets'] + time.sleep(5) + + itf = self.tester.get_interface(self.tester.get_local_port(txPort)) + + destMac = self.dut.get_mac_address(txPort) + self.tester.scapy_foreground() + self.tester.scapy_append( + 'sendp([Ether(dst="%s", src="52:00:00:00:00:00")/IP()], iface="%s")' + % (destMac, itf)) + self.tester.scapy_execute() + time.sleep(3) + + port0_stats = self.get_stats(txPort) + p0tx_bytes = port0_stats['TX-packets'] + port1_stats = self.get_stats(rxPort) + p1rx_err = port1_stats['RX-errors'] + p1rx_bytes = port1_stats['RX-packets'] + time.sleep(5) + + p0tx_bytes -= gp0tx_bytes + p1rx_bytes -= gp1rx_bytes + p1rx_err -= gp1rx_err + + self.verify(p0tx_bytes == p1rx_bytes, + "Wrong TX pkts p0_tx=%d, p1_rx=%d" + % (p0tx_bytes, p1rx_bytes)) + + def positive_test(self, lcores, corelist): + + pmd_cmd = "./%s/app/testpmd --lcores='%s' -n 4 -- -i --portmask=%s" \ + % (self.target, lcores, self.portmask) + out = self.dut.send_expect(pmd_cmd, "testpmd> ", 100) + self.dut.send_expect("set fwd mac", "testpmd>") + self.dut.send_expect("set corelist %s" % corelist, "testpmd> ") + self.dut.send_expect("start", "testpmd> ") + out = self.dut.send_expect("show config fwd", "testpmd> ") + + if ',' in corelist: + corelist = re.split(",", corelist) + self.verify("Logical Core %s " % corelist[0] in out, + "set corelist error:" + out) + print out + self.verify("Logical Core %s " % corelist[1] in out, + "set corelist error:" + out) + else: + self.verify("Logical Core %s " % corelist in out, + "set corelist error:" + out) + self.check_forwarding(self.ports) + cpu = '%cpu' + out = self.dut.alt_session.send_expect( + "ps -C testpmd -L -opid,tid,%s,psr,args | \ + tail -n %s" % (cpu, corelist_num), "#") + result_scanner = "\d+\s+\d+\s+\w+.\w+\s+\d+\s./%s/app/testpmd" \ + % self.target + scanner = re.compile(result_scanner, re.DOTALL) + m = scanner.finditer(out) + + if m: + count = 0 + for i in m: + text = i.group() + self.dut.alt_session.send_expect( + "echo '%s' > /root/temp" % text, "#") + out = self.dut.alt_session.send_expect( + "cat /root/temp | awk '{print $4}'", "#") + if out in cpus: + count += 1 + self.verify(count == corelist_num, + "Threads running error:cpu is %s ." % count) + + self.dut.send_expect("quit", "#") + + def get_corelist(self, lcores): + global cpus + core_list = [] + cpus = [] + if lcores: + print lcores + lcore = re.split(' , ', lcores) + for i in lcore: + if '@' in i: + l_core = re.split('@', i) + l_core_0 = l_core[0] + l_core_1 = l_core[1] + + if '-' in l_core_0: + utils.regexp(i, r'(\d+)') + l__core = re.compile(r'(\d+)').findall(l_core_0) + l__core = map(int, l__core) + if len(l__core) == 2: + l__core.append(l__core[0] + 1) + random_num = map(str, l__core) + for num in random_num: + core_list.append(num) + elif l_core_0[2] == '-' or l_core_0[3] == '-': + l__core.append(l__core[0] + 1) + random_num = map(str, l__core) + for num in random_num: + core_list.append(num) + else: + if l__core[1] < l__core[2]: + l__core.append(l__core[1] + 1) + random_num = map(str, l__core) + for num in random_num: + core_list.append(num) + else: + l__core.append(l__core[1] - 1) + random_num = map(str, l__core) + for num in random_num: + core_list.append(num) + else: + l__core = re.compile(r'(\d+)').findall(l_core_0) + for num in l__core: + core_list.append(num) + if '-' in l_core_1: + utils.regexp(i, r'(\d+)') + l_cpu = re.compile(r'(\d+)').findall(l_core_1) + l_cpu = map(int, l_cpu) + if len(l_cpu) == 2: + l_cpu.append(l_cpu[0] + 1) + random_num = map(str, l_cpu) + for num in random_num: + cpus.append(num) + elif l_core_1[2] == '-' or l_core_1[3] == '-': + l_cpu.append(l_cpu[0] + 1) + random_num = map(str, l_cpu) + for num in random_num: + cpus.append(num) + else: + l_cpu.append(l_cpu[1] - 1) + random_num = map(str, l_cpu) + for num in random_num: + cpus.append(num) + else: + l_cpu = re.compile(r'(\d+)').findall(l_core_1) + for num in l_cpu: + cpus.append(num) + elif '-' in i and '@' not in i: + utils.regexp(i, r'(\d+)') + lcore_num = re.compile(r'(\d+)').findall(i) + lcore_num = map(int, lcore_num) + lcore_num.append(lcore_num[0] + 1) + random_num = map(str, lcore_num) + for num in random_num: + core_list.append(num) + cpus.append(num) + else: + utils.regexp(i, r'(\d+)') + random_num = re.compile(r'(\d+)').findall(i) + for num in random_num: + core_list.append(num) + cpus.append(num) + + core_list = list(set(core_list)) + global corelist_num + corelist_num = len(core_list) + + i = 0 + core_list = map(int, core_list) + b = min(core_list) + while i < len(core_list): + if core_list[i] == b: + del core_list[i] + i -= 1 + else: + i += 1 + + corelist = map(str, core_list) + print corelist, cpus + for i in itertools.combinations(core_list, 2): + i = ",".join(map(str, i)) + corelist.append(i) + print corelist + for core in corelist: + self.positive_test(lcores, core) + + def test_basic_operation(self): + """ + Basic operation + """ + # lcores = '0 @ random_num,(random_num,random_num) @ random_num' + cores = self.dut.get_core_list('all') + random.shuffle(cores) + random_num_0 = random.sample(cores, 2) + random_num_0[0] = '0' + lcore_0 = "@".join(random_num_0) + random_num_1 = tuple(map(int, random.sample(cores, 2))) + random_num_2 = random.randint(1, len(cores) - 1) + lcore_1 = "@".join(map(str, [random_num_1, random_num_2])) + lcores = " , ".join([lcore_0, lcore_1]) + + self.get_corelist(lcores) + + def test_positive_test(self): + """ + Positive Test + """ + cores = self.dut.get_core_list('all') + random_num_0 = str(random.randint(1, len(cores) - 1)) # %d + random_num_1 = tuple(map(int, random.sample(cores, 2))) # (%d,%d) + m = random.randint(1, len(cores) - 3) + random_num_2 = "-".join(map(str, [m, m + 2])) # (%d-%d) + n = random.randint(1, len(cores) - 3) + random_num_3 = "-".join(map(str, [n, n + 2])) # (%d-%d) + j = random.randint(3, len(cores) - 3) + random_num_4 = "-".join(map(str, [j, j - 2])) # (%d-%d) + random_num_5 = str(random.randint(1, len(cores) - 1)) # %d + + #lcore_0 = '0 @ %d,(%d-%d)@(%d-%d)' + core_0 = "@".join(['(%s)', '(%s)']) % (random_num_2, random_num_3) + core_1 = "@".join(['0', random_num_0]) + lcore_0 = " , ".join([core_1, core_0]) + + #lcore_1 = '(0,CONFIG_RTE_MAX_LCORE-1)@(%d,%d)' + core_0 = ",".join(['0', cores[-1]]) + lcore_1 = "@".join(map(str, ['(%s)', random_num_1])) % core_0 + + #lcore_2 = '(0,%d-%d)@(%d,%d)' + core_0 = ",".join(['0', random_num_2]) + lcore_2 = "@".join(map(str, ['(%s)', random_num_1])) % core_0 + + #lcore_3 = '%d-%d,%d,%d-%d' + lcore_3 = " , ".join([random_num_3, random_num_0, random_num_2]) + + #lcore_4 = '%d, (%d-%d)@ %d' + core_0 = "@".join(['(%s)', random_num_0]) % random_num_2 + lcore_4 = " , ".join(['2', core_0]) + + # lcore_5 = '(0,%d1-%d2)@(%d,%d)' %d1 > %d2 + core_0 = ",".join(['0', random_num_4]) + lcore_5 = "@".join(map(str, ['(%s)', random_num_1])) % core_0 + + #lcore_6 = '1 , 2@(0-2,6) , (2-4,6)@5 , (7,8)' + core__0 = ",".join([random_num_2, random_num_0]) + core_0 = "@".join(['2', '(%s)']) % core__0 + core__1 = ",".join([random_num_3, random_num_0]) + core_1 = "@".join(['(%s)', random_num_5]) % core__1 + lcore_6 = " , ".join(['1', core_0, core_1]) + + lcore_s = [lcore_0, lcore_1, lcore_2, + lcore_3, lcore_4, lcore_5, lcore_6] + lcore_s = random.sample(lcore_s, 3) + print lcore_s + for lcores in lcore_s: + self.get_corelist(lcores) + + def test_negative_test(self): + """ + Negative Test + """ + cores = map(int, self.dut.get_core_list('all')) + + lcores = [ + '(0-,%d-%d)@(%d,%d)' % (cores[1], cores[2], cores[-2], cores[-1]), + '(-1,%d-%d)@(%d,%d)' % (cores[1], cores[2], cores[-2], cores[-1]), + '(0,%d-%d-%d)@(%d,%d)' % (cores[1], + cores[2], cores[3], cores[-2], cores[-1]), + '(0,abcd)@(%d,%d)' % (cores[1], cores[2]), + '(0,%d-%d)@(1-,%d)' % (cores[1], cores[2], cores[-2]), + '(0,%d-%d)@(-1,%d)' % (cores[1], cores[2], cores[-2]), + '(0,%d-%d)@(%d,%d-%d-%d)' % (cores[1], cores[2], + cores[3], cores[-3], cores[-2], cores[-1]), + '(0,%d-%d)@(abc,%d)' % (cores[1], cores[2], cores[-2]), + '(0,%d-%d)@(%d,xyz)' % (cores[1], cores[2], cores[-2]), + '(0,%d-%d)=(%d,%d)' % (cores[1], cores[2], cores[-2], cores[-1]), + '%d,%d @ %d,(0-1,,%d))' % (cores[1], + cores[2], cores[-2], cores[-1]), + '[0-,%d-%d]@(%d,%d)' % (cores[1], cores[2], cores[-2], cores[-1]), + '(0-,%d-%d)@[%d,%d]' % (cores[1], cores[2], cores[-2], cores[-1]), + '%d-%d @ %d,%d @ %d-%d' % (cores[1], cores[2], + cores[2], cores[-3], cores[-2], cores[-1]), + '%d,,%d''%d--%d' % (cores[1], cores[2], cores[1], cores[2]), + '%d,,,%d''%d--%d' % (cores[1], cores[2], cores[1], cores[2])] + + for lcore in lcores: + pmd_cmd = "./%s/app/testpmd --lcores='%s' -n 4 -- -i --portmask=%s" \ + % (self.target, lcore, self.portmask) + self.dut.send_expect(pmd_cmd, "#", 100) + + def tear_down(self): + """ + Run after each test case. + """ + self.dut.kill_all() + + def tear_down_all(self): + """ + Run after each test suite. + """ + pass -- 2.5.0