From f463c563912abb806fe0d2fe85a4cf6825f416cc Mon Sep 17 00:00:00 2001 From: Dino Simeon Madarang Date: Mon, 19 Oct 2015 14:55:06 +0100 Subject: Add OVS tunnel encapsulation performance test Measure OVS DPDK and native VXLAN/GRE/GENEVE encapsulation performance. This patch creates a new deployment scenario, Overlay_P2P. The DUT is configured as a TEP (Tunnel Endpoint) which performs encapsulation of frames and sends traffic to the 2nd traffic generator port. The traffic generator in this case receives an encapsulated frame. No decapsulation is performed in this testcase. Introduce a vsperf param, --run-integration, to filter tests to integration tests. When running integration tests, variables defined in the directory conf/integration/*conf as well as the conf/*.conf are available. This test case requires DPDK 2.1.0 and OVS master - 6bb4a18 or newer. Change-Id: Ide2f418909d647119388df9b30d0d0a3656b4e53 JIRA: VSPERF-180 Signed-off-by: Dino Simeon Madarang Reviewed-by: Maryam Tahhan Reviewed-by: Al Morton --- core/component_factory.py | 7 +- core/vnf_controller.py | 6 +- core/vswitch_controller_op2p.py | 140 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 149 insertions(+), 4 deletions(-) create mode 100644 core/vswitch_controller_op2p.py (limited to 'core') diff --git a/core/component_factory.py b/core/component_factory.py index af237e50..1e5f2266 100644 --- a/core/component_factory.py +++ b/core/component_factory.py @@ -1,4 +1,4 @@ -# Copyright 2015 Intel Corporation. +# Copyright 2015-2016 Intel Corporation. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. @@ -19,6 +19,7 @@ from core.traffic_controller_rfc2544 import TrafficControllerRFC2544 from core.vswitch_controller_p2p import VswitchControllerP2P from core.vswitch_controller_pvp import VswitchControllerPVP from core.vswitch_controller_pvvp import VswitchControllerPVVP +from core.vswitch_controller_op2p import VswitchControllerOP2P from core.vnf_controller import VnfController from core.pktfwd_controller import PktFwdController from tools.load_gen.stress.stress import Stress @@ -61,12 +62,14 @@ def create_vswitch(deployment_scenario, vswitch_class, traffic): :return: IVSwitchController for the deployment_scenario """ deployment_scenario = deployment_scenario.lower() - if deployment_scenario.find("p2p") >= 0: + if deployment_scenario.find("p2p") == 0: return VswitchControllerP2P(vswitch_class, traffic) elif deployment_scenario.find("pvp") >= 0: return VswitchControllerPVP(vswitch_class, traffic) elif deployment_scenario.find("pvvp") >= 0: return VswitchControllerPVVP(vswitch_class, traffic) + elif deployment_scenario.find("op2p") >= 0: + return VswitchControllerOP2P(vswitch_class, traffic) def create_vnf(deployment_scenario, vnf_class): """Return a new VnfController for the deployment_scenario. diff --git a/core/vnf_controller.py b/core/vnf_controller.py index 3313e9e3..e973bc51 100644 --- a/core/vnf_controller.py +++ b/core/vnf_controller.py @@ -1,4 +1,4 @@ -# Copyright 2015 Intel Corporation. +# Copyright 2015-2016 Intel Corporation. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. @@ -43,10 +43,12 @@ class VnfController(object): self._deployment_scenario = deployment_scenario.upper() if self._deployment_scenario == 'P2P': self._vnfs = [] - if self._deployment_scenario == 'PVP': + elif self._deployment_scenario == 'PVP': self._vnfs = [vnf_class()] elif self._deployment_scenario == 'PVVP': self._vnfs = [vnf_class(), vnf_class()] + elif self._deployment_scenario == 'OP2P': + self._vnfs = [] self._logger.debug('__init__ ' + str(len(self._vnfs)) + ' VNF[s] with ' + ' '.join(map(str, self._vnfs))) diff --git a/core/vswitch_controller_op2p.py b/core/vswitch_controller_op2p.py new file mode 100644 index 00000000..69c88c35 --- /dev/null +++ b/core/vswitch_controller_op2p.py @@ -0,0 +1,140 @@ +# Copyright 2015-2016 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. + +"""VSwitch controller for Physical to Tunnel Endpoint to Physical deployment +""" + +import logging + +from core.vswitch_controller import IVswitchController +from vswitches.utils import add_ports_to_flow +from conf import settings +from tools import tasks + +_FLOW_TEMPLATE = { + 'idle_timeout': '0' +} + +class VswitchControllerOP2P(IVswitchController): + """VSwitch controller for OP2P deployment scenario. + + Attributes: + _vswitch_class: The vSwitch class to be used. + _vswitch: The vSwitch object controlled by this controller + _deployment_scenario: A string describing the scenario to set-up in the + constructor. + """ + def __init__(self, vswitch_class, traffic): + """Initializes up the prerequisites for the OP2P deployment scenario. + + :vswitch_class: the vSwitch class to be used. + """ + self._logger = logging.getLogger(__name__) + self._vswitch_class = vswitch_class + self._vswitch = vswitch_class() + self._deployment_scenario = "OP2P" + self._traffic = traffic.copy() + self._logger.debug('Creation using ' + str(self._vswitch_class)) + + def setup(self): + """ Sets up the switch for overlay P2P + + Create 2 bridges br0 (integration bridge) and br-ext and a VXLAN port + for encapsulation. + """ + self._logger.debug('Setup using ' + str(self._vswitch_class)) + + try: + self._vswitch.start() + bridge = settings.getValue('TUNNEL_INTEGRATION_BRIDGE') + bridge_ext = settings.getValue('TUNNEL_EXTERNAL_BRIDGE') + bridge_ext_ip = settings.getValue('TUNNEL_EXTERNAL_BRIDGE_IP') + tg_port2_mac = settings.getValue('TRAFFICGEN_PORT2_MAC') + vtep_ip2 = settings.getValue('VTEP_IP2') + self._vswitch.add_switch(bridge) + + tasks.run_task(['sudo', 'ifconfig', bridge, + settings.getValue('VTEP_IP1')], + self._logger, 'Assign ' + + settings.getValue('VTEP_IP1') + ' to ' + bridge, + False) + + tunnel_type = self._traffic['tunnel_type'] + + self._vswitch.add_switch(bridge_ext) + (_, phy1_number) = self._vswitch.add_phy_port(bridge) + (_, phy2_number) = self._vswitch.add_tunnel_port(bridge, + vtep_ip2, + tunnel_type) + self._vswitch.add_phy_port(bridge_ext) + + tasks.run_task(['sudo', 'ip', 'addr', 'add', + bridge_ext_ip, + 'dev', bridge_ext], self._logger, 'Assign ' + + bridge_ext_ip + ' to ' + bridge_ext) + + tasks.run_task(['sudo', 'ip', 'link', 'set', 'dev', bridge_ext, + 'up'], self._logger, + 'Set ' + bridge_ext + 'status to up') + + self._vswitch.add_route(bridge, + settings.getValue('VTEP_IP2_SUBNET'), + bridge_ext) + + if settings.getValue('VSWITCH').endswith('Vanilla'): + tasks.run_task(['sudo', 'arp', '-s', vtep_ip2, tg_port2_mac], + self._logger, + 'Set ' + bridge_ext + 'status to up') + else: + self._vswitch.set_tunnel_arp(vtep_ip2, + tg_port2_mac, + bridge_ext) + + # Test is unidirectional for now + self._vswitch.del_flow(bridge) + flow1 = add_ports_to_flow(_FLOW_TEMPLATE, phy1_number, + phy2_number) + self._vswitch.add_flow(bridge, flow1) + + except: + self._vswitch.stop() + raise + + def stop(self): + """Tears down the switch created in setup(). + """ + self._logger.debug('Stop using ' + str(self._vswitch_class)) + self._vswitch.stop() + + def __enter__(self): + self.setup() + + def __exit__(self, type_, value, traceback): + self.stop() + + def get_vswitch(self): + """See IVswitchController for description + """ + return self._vswitch + + def get_ports_info(self): + """See IVswitchController for description + """ + self._logger.debug('get_ports_info using ' + str(self._vswitch_class)) + return self._vswitch.get_ports(settings.getValue('VSWITCH_BRIDGE_NAME')) + + def dump_vswitch_flows(self): + """See IVswitchController for description + """ + self._vswitch.dump_flows(settings.getValue('VSWITCH_BRIDGE_NAME')) -- cgit 1.2.3-korg