diff options
Diffstat (limited to 'yardstick/network_services')
6 files changed, 252 insertions, 129 deletions
diff --git a/yardstick/network_services/traffic_profile/prox_mpls_tag_untag.py b/yardstick/network_services/traffic_profile/prox_mpls_tag_untag.py deleted file mode 100644 index 0e1048b5d..000000000 --- a/yardstick/network_services/traffic_profile/prox_mpls_tag_untag.py +++ /dev/null @@ -1,99 +0,0 @@ -# Copyright (c) 2016-2017 Intel Corporation -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -""" Fixed traffic profile definitions """ - -from __future__ import absolute_import - -import logging - -from yardstick.network_services.traffic_profile.prox_profile import ProxProfile - -LOG = logging.getLogger(__name__) - - -class ProxMplsTagUntagProfile(ProxProfile): - """ - This profile adds a single stream at the beginning of the traffic session - """ - - def __init__(self, tp_config): - super(ProxMplsTagUntagProfile, self).__init__(tp_config) - self.current_lower = self.lower_bound - self.current_upper = self.upper_bound - - @property - def delta(self): - return self.current_upper - self.current_lower - - @property - def mid_point(self): - return (self.current_lower + self.current_upper) / 2 - - def bounds_iterator(self, logger=None): - self.current_lower = self.lower_bound - self.current_upper = self.upper_bound - - test_value = self.current_upper - while abs(self.delta) >= self.precision: - if logger: - logger.debug("New interval [%s, %s), precision: %d", self.current_lower, - self.current_upper, self.step_value) - logger.info("Testing with value %s", test_value) - - yield test_value - test_value = self.mid_point - - def run_test_with_pkt_size(self, traffic_gen, pkt_size, duration): - """Run the test for a single packet size. - - :param traffic_gen: traffic generator instance - :type traffic_gen: TrafficGen - :param pkt_size: The packet size to test with. - :type pkt_size: int - :param duration: The duration for each try. - :type duration: int - - """ - - LOG.info("Testing with packet size %d", pkt_size) - - # Binary search assumes the lower value of the interval is - # successful and the upper value is a failure. - # The first value that is tested, is the maximum value. If that - # succeeds, no more searching is needed. If it fails, a regular - # binary search is performed. - # - # The test_value used for the first iteration of binary search - # is adjusted so that the delta between this test_value and the - # upper bound is a power-of-2 multiple of precision. In the - # optimistic situation where this first test_value results in a - # success, the binary search will complete on an integer multiple - # of the precision, rather than on a fraction of it. - - # throughput and packet loss from the most recent successful test - successful_pkt_loss = 0.0 - for test_value in self.bounds_iterator(LOG): - result, port_samples = self._profile_helper.run_test(pkt_size, duration, - test_value, self.tolerated_loss) - - if result.success: - LOG.debug("Success! Increasing lower bound") - self.current_lower = test_value - successful_pkt_loss = result.pkt_loss - else: - LOG.debug("Failure... Decreasing upper bound") - self.current_upper = test_value - - samples = result.get_samples(pkt_size, successful_pkt_loss, port_samples) - self.queue.put(samples) diff --git a/yardstick/network_services/traffic_profile/rfc2544.py b/yardstick/network_services/traffic_profile/rfc2544.py index 16e809b65..b1ca8a345 100644 --- a/yardstick/network_services/traffic_profile/rfc2544.py +++ b/yardstick/network_services/traffic_profile/rfc2544.py @@ -62,7 +62,7 @@ class RFC2544Profile(TrexProfile): self.generator.rfc2544_helper.correlated_traffic: continue for intf in intfs: - port = self.generator.vnfd_helper.port_num(intf) + port = self.generator.port_num(intf) self.ports.append(port) self.generator.client.add_streams(self.get_streams(profile_data), ports=port) @@ -170,7 +170,7 @@ class RFC2544Profile(TrexProfile): self.generator.rfc2544_helper.correlated_traffic: continue for intf in intfs: - port = self.generator.vnfd_helper.port_num(intf) + port = self.generator.port_num(intf) self.ports.append(port) self.generator.client.add_streams(self.get_streams(profile_data), ports=port) diff --git a/yardstick/network_services/utils.py b/yardstick/network_services/utils.py index eac3c814f..7a1815eb9 100644 --- a/yardstick/network_services/utils.py +++ b/yardstick/network_services/utils.py @@ -22,6 +22,7 @@ from oslo_config import cfg from oslo_config.cfg import NoSuchOptError from oslo_utils import encodeutils + NSB_ROOT = "/opt/nsb_bin" CONF = cfg.CONF @@ -43,30 +44,37 @@ HEXADECIMAL = "[0-9a-zA-Z]" class PciAddress(object): + """Class to handle PCI addresses. - PCI_PATTERN_STR = HEXADECIMAL.join([ - "(", - "{4}):(", # domain (4 bytes) - "{2}):(", # bus (2 bytes) - "{2}).(", # function (2 bytes) - ")", # slot (1 byte) - ]) + A PCI address could be written in two ways: + - Simple BDF notation: + 00:00.0 # bus:device.function + - With domain extension. + 0000:00:00.0 # domain:bus:device.function - PCI_PATTERN = re.compile(PCI_PATTERN_STR) + Note: in Libvirt, 'device' is called 'slot'. - @classmethod - def parse_address(cls, text, multi_line=False): - if multi_line: - text = text.replace(os.linesep, '') - match = cls.PCI_PATTERN.search(text) - return cls(match.group(0)) + Reference: https://wiki.xenproject.org/wiki/ + Bus:Device.Function_(BDF)_Notation + """ + PCI_PATTERN_STR = ( + r"((?P<domain>[0-9a-zA-Z]{4}):)?(?P<bus>[0-9a-zA-Z]{2}):" + r"(?P<slot>[0-9a-zA-Z]{2})\.(?P<function>[0-9a-zA-Z]{1})") def __init__(self, address): - super(PciAddress, self).__init__() - match = self.PCI_PATTERN.match(address) + pci_pattern = re.compile(self.PCI_PATTERN_STR) + match = pci_pattern.search(address) if not match: raise ValueError('Invalid PCI address: {}'.format(address)) - self.address = address + + self._domain = (match.group('domain') or '0000').lower() + self._bus = match.group('bus').lower() + self._slot = match.group('slot').lower() + self._function = match.group('function').lower() + self.address = '{:0>4}:{:0>2}:{:0>2}.{:1}'.format(self.domain, + self.bus, + self.slot, + self.function) self.match = match def __repr__(self): @@ -74,22 +82,22 @@ class PciAddress(object): @property def domain(self): - return self.match.group(1) + return self._domain @property def bus(self): - return self.match.group(2) + return self._bus @property def slot(self): - return self.match.group(3) + return self._slot @property def function(self): - return self.match.group(4) + return self._function def values(self): - return [self.match.group(n) for n in range(1, 5)] + return [self._domain, self._bus, self._slot, self._function] def get_nsb_option(option, default=None): diff --git a/yardstick/network_services/vnf_generic/vnf/prox_helpers.py b/yardstick/network_services/vnf_generic/vnf/prox_helpers.py index ac5abfbcb..d9acae2f2 100644 --- a/yardstick/network_services/vnf_generic/vnf/prox_helpers.py +++ b/yardstick/network_services/vnf_generic/vnf/prox_helpers.py @@ -1490,7 +1490,6 @@ class ProxVpeProfileHelper(ProxProfileHelper): if item_key != 'name': continue - for item_key, item_value in section: if item_value.startswith("cpe"): cpe_ports.append(tx_port_no) @@ -1595,3 +1594,192 @@ class ProxVpeProfileHelper(ProxProfileHelper): data_helper.latency = self.get_latency() return data_helper.result_tuple, data_helper.samples + + +class ProxlwAFTRProfileHelper(ProxProfileHelper): + + __prox_profile_type__ = "lwAFTR gen" + + def __init__(self, resource_helper): + super(ProxlwAFTRProfileHelper, self).__init__(resource_helper) + self._cores_tuple = None + self._ports_tuple = None + self.step_delta = 5 + self.step_time = 0.5 + + @property + def _lwaftr_cores(self): + if not self._cores_tuple: + self._cores_tuple = self._get_cores_gen_lwaftr() + return self._cores_tuple + + @property + def tun_cores(self): + return self._lwaftr_cores[0] + + @property + def inet_cores(self): + return self._lwaftr_cores[1] + + @property + def _lwaftr_ports(self): + if not self._ports_tuple: + self._ports_tuple = self._get_ports_gen_lw_aftr() + return self._ports_tuple + + @property + def tun_ports(self): + return self._lwaftr_ports[0] + + @property + def inet_ports(self): + return self._lwaftr_ports[1] + + @property + def all_rx_cores(self): + return self.latency_cores + + def _get_cores_gen_lwaftr(self): + tun_cores = [] + inet_cores = [] + for section_name, section in self.resource_helper.setup_helper.prox_config_data: + if not section_name.startswith("core"): + continue + + if all(key != "mode" or value != self.PROX_CORE_GEN_MODE for key, value in section): + continue + + core_tuple = CoreSocketTuple(section_name) + core_tag = core_tuple.find_in_topology(self.cpu_topology) + for item_value in (v for k, v in section if k == 'name'): + if item_value.startswith('tun'): + tun_cores.append(core_tag) + elif item_value.startswith('inet'): + inet_cores.append(core_tag) + + return tun_cores, inet_cores + + def _get_ports_gen_lw_aftr(self): + tun_ports = [] + inet_ports = [] + + re_port = re.compile('port (\d+)') + for section_name, section in self.resource_helper.setup_helper.prox_config_data: + match = re_port.search(section_name) + if not match: + continue + + tx_port_no = int(match.group(1)) + for item_value in (v for k, v in section if k == 'name'): + if item_value.startswith('lwB4'): + tun_ports.append(tx_port_no) + elif item_value.startswith('inet'): + inet_ports.append(tx_port_no) + + return tun_ports, inet_ports + + @staticmethod + def _resize(len1, len2): + if len1 == len2: + return 1.0 + return 1.0 * len1 / len2 + + @contextmanager + def traffic_context(self, pkt_size, value): + # Tester is sending packets at the required speed already after + # setup_test(). Just get the current statistics, sleep the required + # amount of time and calculate packet loss. + tun_pkt_size = pkt_size + inet_pkt_size = pkt_size - 40 + ratio = 1.0 * (tun_pkt_size + 20) / (inet_pkt_size + 20) + + curr_up_speed = curr_down_speed = 0 + max_up_speed = max_down_speed = value + + max_up_speed = value / ratio + + # Adjust speed when multiple cores per port are used to generate traffic + if len(self.tun_ports) != len(self.tun_cores): + max_down_speed *= self._resize(len(self.tun_ports), len(self.tun_cores)) + if len(self.inet_ports) != len(self.inet_cores): + max_up_speed *= self._resize(len(self.inet_ports), len(self.inet_cores)) + + # Initialize cores + self.sut.stop_all() + time.sleep(0.5) + + # Flush any packets in the NIC RX buffers, otherwise the stats will be + # wrong. + self.sut.start(self.all_rx_cores) + time.sleep(0.5) + self.sut.stop(self.all_rx_cores) + time.sleep(0.5) + self.sut.reset_stats() + + self.sut.set_pkt_size(self.inet_cores, inet_pkt_size) + self.sut.set_pkt_size(self.tun_cores, tun_pkt_size) + + self.sut.reset_values(self.tun_cores) + self.sut.reset_values(self.inet_cores) + + # Set correct IP and UDP lengths in packet headers + # tun + # IPv6 length (byte 18): 58 for MAC(12), EthType(2), IPv6(40) , CRC(4) + self.sut.set_value(self.tun_cores, 18, tun_pkt_size - 58, 2) + # IP length (byte 56): 58 for MAC(12), EthType(2), CRC(4) + self.sut.set_value(self.tun_cores, 56, tun_pkt_size - 58, 2) + # UDP length (byte 78): 78 for MAC(12), EthType(2), IP(20), UDP(8), CRC(4) + self.sut.set_value(self.tun_cores, 78, tun_pkt_size - 78, 2) + + # INET + # IP length (byte 20): 22 for MAC(12), EthType(2), CRC(4) + self.sut.set_value(self.inet_cores, 16, inet_pkt_size - 18, 2) + # UDP length (byte 42): 42 for MAC(12), EthType(2), IP(20), UPD(8), CRC(4) + self.sut.set_value(self.inet_cores, 38, inet_pkt_size - 38, 2) + + LOG.info("Initializing SUT: sending lwAFTR packets") + self.sut.set_speed(self.inet_cores, curr_up_speed) + self.sut.set_speed(self.tun_cores, curr_down_speed) + time.sleep(4) + + # Ramp up the transmission speed. First go to the common speed, then + # increase steps for the faster one. + self.sut.start(self.tun_cores + self.inet_cores + self.latency_cores) + + LOG.info("Ramping up speed to %s up, %s down", max_up_speed, max_down_speed) + + while (curr_up_speed < max_up_speed) or (curr_down_speed < max_down_speed): + # The min(..., ...) takes care of 1) floating point rounding errors + # that could make curr_*_speed to be slightly greater than + # max_*_speed and 2) max_*_speed not being an exact multiple of + # self._step_delta. + if curr_up_speed < max_up_speed: + curr_up_speed = min(curr_up_speed + self.step_delta, max_up_speed) + if curr_down_speed < max_down_speed: + curr_down_speed = min(curr_down_speed + self.step_delta, max_down_speed) + + self.sut.set_speed(self.inet_cores, curr_up_speed) + self.sut.set_speed(self.tun_cores, curr_down_speed) + time.sleep(self.step_time) + + LOG.info("Target speeds reached. Starting real test.") + + yield + + self.sut.stop(self.tun_cores + self.inet_cores) + LOG.info("Test ended. Flushing NIC buffers") + self.sut.start(self.all_rx_cores) + time.sleep(3) + self.sut.stop(self.all_rx_cores) + + def run_test(self, pkt_size, duration, value, tolerated_loss=0.0): + data_helper = ProxDataHelper(self.vnfd_helper, self.sut, pkt_size, value, tolerated_loss) + + with data_helper, self.traffic_context(pkt_size, value): + with data_helper.measure_tot_stats(): + time.sleep(duration) + # Getting statistics to calculate PPS at right speed.... + data_helper.capture_tsc_hz() + data_helper.latency = self.get_latency() + + return data_helper.result_tuple, data_helper.samples diff --git a/yardstick/network_services/vnf_generic/vnf/sample_vnf.py b/yardstick/network_services/vnf_generic/vnf/sample_vnf.py index 08ec44f65..5599c0a3b 100644 --- a/yardstick/network_services/vnf_generic/vnf/sample_vnf.py +++ b/yardstick/network_services/vnf_generic/vnf/sample_vnf.py @@ -433,6 +433,10 @@ class ClientResourceHelper(ResourceHelper): self.vnfd_helper.port_nums(self.vnfd_helper.port_pairs.downlink_ports) self.all_ports = self.vnfd_helper.port_nums(self.vnfd_helper.port_pairs.all_ports) + def port_num(self, intf): + # by default return port num + return self.vnfd_helper.port_num(intf) + def get_stats(self, *args, **kwargs): try: return self.client.get_stats(*args, **kwargs) diff --git a/yardstick/network_services/vnf_generic/vnf/tg_trex.py b/yardstick/network_services/vnf_generic/vnf/tg_trex.py index 458f1b844..93ba8557a 100644 --- a/yardstick/network_services/vnf_generic/vnf/tg_trex.py +++ b/yardstick/network_services/vnf_generic/vnf/tg_trex.py @@ -48,27 +48,38 @@ class TrexResourceHelper(ClientResourceHelper): ASYNC_PORT = 4500 SYNC_PORT = 4501 + def __init__(self, setup_helper): + super(TrexResourceHelper, self).__init__(setup_helper) + self.port_map = {} + self.dpdk_to_trex_port_map = {} + def generate_cfg(self): port_names = self.vnfd_helper.port_pairs.all_ports vpci_list = [] port_list = [] + self.port_map = {} + self.dpdk_to_trex_port_map = {} - port_nums = sorted(self.vnfd_helper.port_nums(port_names)) - for port_num in port_nums: - interface = self.vnfd_helper.find_interface_by_port(port_num) + sorted_ports = sorted((self.vnfd_helper.port_num(port_name), port_name) for port_name in + port_names) + for index, (port_num, port_name) in enumerate(sorted_ports): + interface = self.vnfd_helper.find_interface(name=port_name) virtual_interface = interface['virtual-interface'] dst_mac = virtual_interface["dst_mac"] - # why skip?, ordering is based on DPDK port number so we can't skip + # this is to check for unused ports, all ports in the topology + # will always have dst_mac if not dst_mac: continue - # TRex ports must be in DPDK port number, so order of append matters + # TRex ports are in logical order roughly based on DPDK port number sorting vpci_list.append(virtual_interface["vpci"]) local_mac = virtual_interface["local_mac"] port_list.append({ "src_mac": mac_address_to_hex_list(local_mac), "dest_mac": mac_address_to_hex_list(dst_mac), }) + self.port_map[port_name] = index + self.dpdk_to_trex_port_map[port_num] = index trex_cfg = { 'interfaces': vpci_list, 'port_info': port_list, @@ -80,6 +91,17 @@ class TrexResourceHelper(ClientResourceHelper): cfg_str = yaml.safe_dump(cfg_file, default_flow_style=False, explicit_start=True) self.ssh_helper.upload_config_file(os.path.basename(self.CONF_FILE), cfg_str) + def _build_ports(self): + super(TrexResourceHelper, self)._build_ports() + # override with TRex logic port number + self.uplink_ports = [self.dpdk_to_trex_port_map[p] for p in self.uplink_ports] + self.downlink_ports = [self.dpdk_to_trex_port_map[p] for p in self.downlink_ports] + self.all_ports = [self.dpdk_to_trex_port_map[p] for p in self.all_ports] + + def port_num(self, intf): + # return logical TRex port + return self.port_map[intf] + def check_status(self): status, _, _ = self.ssh_helper.execute("sudo lsof -i:%s" % self.SYNC_PORT) return status |