yardstick/network_services/vnf_generic/vnf/prox_irq.py

   1 # Copyright (c) 2018 Intel Corporation
   2 #
   3 # Licensed under the Apache License, Version 2.0 (the "License");
   4 # you may not use this file except in compliance with the License.
   5 # You may obtain a copy of the License at
   6 #
   7 #      http://www.apache.org/licenses/LICENSE-2.0
   8 #
   9 # Unless required by applicable law or agreed to in writing, software
  10 # distributed under the License is distributed on an "AS IS" BASIS,
  11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 # See the License for the specific language governing permissions and
  13 # limitations under the License.
  14
  15 import errno
  16 import logging
  17 import copy
  18 import time
  19
  20 from yardstick.common.process import check_if_process_failed
  21 from yardstick.network_services.utils import get_nsb_option
  22 from yardstick.network_services.vnf_generic.vnf.prox_vnf import ProxApproxVnf
  23 from yardstick.network_services.vnf_generic.vnf.sample_vnf import SampleVNFTrafficGen
  24 from yardstick.benchmark.contexts.base import Context
  25 from yardstick.network_services.vnf_generic.vnf.prox_helpers import CoreSocketTuple
  26 LOG = logging.getLogger(__name__)
  27
  28
  29 class ProxIrq(SampleVNFTrafficGen):
  30
  31     def __init__(self, name, vnfd, task_id, setup_env_helper_type=None,
  32                  resource_helper_type=None):
  33         vnfd_cpy = copy.deepcopy(vnfd)
  34         super(ProxIrq, self).__init__(name, vnfd_cpy, task_id)
  35
  36         self._vnf_wrapper = ProxApproxVnf(
  37             name, vnfd, task_id, setup_env_helper_type, resource_helper_type)
  38         self.bin_path = get_nsb_option('bin_path', '')
  39         self.name = self._vnf_wrapper.name
  40         self.ssh_helper = self._vnf_wrapper.ssh_helper
  41         self.setup_helper = self._vnf_wrapper.setup_helper
  42         self.resource_helper = self._vnf_wrapper.resource_helper
  43         self.scenario_helper = self._vnf_wrapper.scenario_helper
  44         self.irq_cores = None
  45
  46     def terminate(self):
  47         self._vnf_wrapper.terminate()
  48         super(ProxIrq, self).terminate()
  49
  50     def instantiate(self, scenario_cfg, context_cfg):
  51         self._vnf_wrapper.instantiate(scenario_cfg, context_cfg)
  52         self._tg_process = self._vnf_wrapper._vnf_process
  53
  54     def wait_for_instantiate(self):
  55         self._vnf_wrapper.wait_for_instantiate()
  56
  57     def get_irq_cores(self):
  58         cores = []
  59         mode = "irq"
  60
  61         for section_name, section in self.setup_helper.prox_config_data:
  62             if not section_name.startswith("core"):
  63                 continue
  64             irq_mode = task_present = False
  65             task_present_task = 0
  66             for key, value in section:
  67                 if key == "mode" and value == mode:
  68                     irq_mode = True
  69                 if key == "task":
  70                     task_present = True
  71                     task_present_task = int(value)
  72
  73             if irq_mode:
  74                 if not task_present:
  75                     task_present_task = 0
  76                 core_tuple = CoreSocketTuple(section_name)
  77                 core = core_tuple.core_id
  78                 cores.append((core, task_present_task))
  79
  80         return cores
  81
  82 class ProxIrqVNF(ProxIrq, SampleVNFTrafficGen):
  83
  84     APP_NAME = 'ProxIrqVNF'
  85
  86     def __init__(self, name, vnfd, task_id, setup_env_helper_type=None,
  87                  resource_helper_type=None):
  88         ProxIrq.__init__(self, name, vnfd, task_id, setup_env_helper_type,
  89                         resource_helper_type)
  90
  91         self.start_test_time = None
  92         self.end_test_time = None
  93
  94     def vnf_execute(self, cmd, *args, **kwargs):
  95         ignore_errors = kwargs.pop("_ignore_errors", False)
  96         try:
  97             return self.resource_helper.execute(cmd, *args, **kwargs)
  98         except OSError as e:
  99             if e.errno in {errno.EPIPE, errno.ESHUTDOWN, errno.ECONNRESET}:
 100                 if ignore_errors:
 101                     LOG.debug("ignoring vnf_execute exception %s for command %s", e, cmd)
 102                 else:
 103                     raise
 104             else:
 105                 raise
 106
 107     def collect_kpi(self):
 108         # check if the tg processes have exited
 109         physical_node = Context.get_physical_node_from_server(
 110             self.scenario_helper.nodes[self.name])
 111
 112         result = {"physical_node": physical_node}
 113         for proc in (self._tg_process, self._traffic_process):
 114             check_if_process_failed(proc)
 115
 116         if self.resource_helper is None:
 117             return result
 118
 119         if self.irq_cores is None:
 120             self.setup_helper.build_config_file()
 121             self.irq_cores = self.get_irq_cores()
 122
 123         data = self.vnf_execute('irq_core_stats', self.irq_cores)
 124         new_data = copy.deepcopy(data)
 125
 126         self.end_test_time = time.time()
 127         self.vnf_execute('reset_stats')
 128
 129         if self.start_test_time is None:
 130             new_data = {}
 131         else:
 132             test_time = self.end_test_time - self.start_test_time
 133             for index, item in data.items():
 134                 for counter, value in item.items():
 135                     if counter.startswith("bucket_")or \
 136                             counter.startswith("overflow"):
 137                         if value is 0:
 138                             del new_data[index][counter]
 139                         else:
 140                             new_data[index][counter] = float(value) / test_time
 141
 142         self.start_test_time = time.time()
 143
 144         result["collect_stats"] = new_data
 145         LOG.debug("%s collect KPIs %s", self.APP_NAME, result)
 146
 147         return result
 148
 149 class ProxIrqGen(ProxIrq, SampleVNFTrafficGen):
 150
 151     APP_NAME = 'ProxIrqGen'
 152
 153     def __init__(self, name, vnfd, task_id, setup_env_helper_type=None,
 154                  resource_helper_type=None):
 155         ProxIrq.__init__(self, name, vnfd, task_id, setup_env_helper_type,
 156                                       resource_helper_type)
 157         self.start_test_time = None
 158         self.end_test_time = None
 159
 160     def collect_kpi(self):
 161         # check if the tg processes have exited
 162         physical_node = Context.get_physical_node_from_server(
 163             self.scenario_helper.nodes[self.name])
 164
 165         result = {"physical_node": physical_node}
 166         for proc in (self._tg_process, self._traffic_process):
 167             check_if_process_failed(proc)
 168
 169         if self.resource_helper is None:
 170             return result
 171
 172         if self.irq_cores is None:
 173             self.setup_helper.build_config_file()
 174             self.irq_cores = self.get_irq_cores()
 175
 176         data = self.resource_helper.sut.irq_core_stats(self.irq_cores)
 177         new_data = copy.deepcopy(data)
 178
 179         self.end_test_time = time.time()
 180         self.resource_helper.sut.reset_stats()
 181
 182         if self.start_test_time is None:
 183             new_data = {}
 184         else:
 185             test_time = self.end_test_time - self.start_test_time
 186             for index, item in data.items():
 187                 for counter, value in item.items():
 188                     if counter.startswith("bucket_") or \
 189                             counter.startswith("overflow"):
 190                         if value is 0:
 191                             del new_data[index][counter]
 192                         else:
 193                             new_data[index][counter] = float(value) / test_time
 194
 195         self.start_test_time = time.time()
 196
 197         result["collect_stats"] = new_data
 198         LOG.debug("%s collect KPIs %s", self.APP_NAME, result)
 199
 200         return result