yardstick/network_services/traffic_profile/prox_binsearch.py

   1 # Copyright (c) 2016-2017 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 """ Fixed traffic profile definitions """
  15
  16 from __future__ import absolute_import
  17
  18 import logging
  19 import datetime
  20 import time
  21
  22 from yardstick.network_services.traffic_profile.prox_profile import ProxProfile
  23
  24 LOG = logging.getLogger(__name__)
  25
  26
  27 class ProxBinSearchProfile(ProxProfile):
  28     """
  29     This profile adds a single stream at the beginning of the traffic session
  30     """
  31
  32     def __init__(self, tp_config):
  33         super(ProxBinSearchProfile, self).__init__(tp_config)
  34         self.current_lower = self.lower_bound
  35         self.current_upper = self.upper_bound
  36
  37     @property
  38     def delta(self):
  39         return self.current_upper - self.current_lower
  40
  41     @property
  42     def mid_point(self):
  43         return (self.current_lower + self.current_upper) / 2
  44
  45     def bounds_iterator(self, logger=None):
  46         self.current_lower = self.lower_bound
  47         self.current_upper = self.upper_bound
  48
  49         test_value = self.current_upper
  50         while abs(self.delta) >= self.precision:
  51             if logger:
  52                 logger.debug("New interval [%s, %s), precision: %d", self.current_lower,
  53                              self.current_upper, self.step_value)
  54                 logger.info("Testing with value %s", test_value)
  55
  56             yield test_value
  57             test_value = self.mid_point
  58
  59     def run_test_with_pkt_size(self, traffic_gen, pkt_size, duration):
  60         """Run the test for a single packet size.
  61
  62         :param traffic_gen: traffic generator instance
  63         :type traffic_gen: TrafficGen
  64         :param  pkt_size: The packet size to test with.
  65         :type pkt_size: int
  66         :param  duration: The duration for each try.
  67         :type duration: int
  68
  69         """
  70
  71         LOG.info("Testing with packet size %d", pkt_size)
  72
  73         # Binary search assumes the lower value of the interval is
  74         # successful and the upper value is a failure.
  75         # The first value that is tested, is the maximum value. If that
  76         # succeeds, no more searching is needed. If it fails, a regular
  77         # binary search is performed.
  78         #
  79         # The test_value used for the first iteration of binary search
  80         # is adjusted so that the delta between this test_value and the
  81         # upper bound is a power-of-2 multiple of precision. In the
  82         # optimistic situation where this first test_value results in a
  83         # success, the binary search will complete on an integer multiple
  84         # of the precision, rather than on a fraction of it.
  85
  86         theor_max_thruput = 0
  87
  88         result_samples = {}
  89
  90         # Store one time only value in influxdb
  91         single_samples = {
  92             "test_duration" : traffic_gen.scenario_helper.scenario_cfg["runner"]["duration"],
  93             "test_precision" : self.params["traffic_profile"]["test_precision"],
  94             "tolerated_loss" : self.params["traffic_profile"]["tolerated_loss"],
  95             "duration" : duration
  96         }
  97         self.queue.put(single_samples)
  98         self.prev_time = time.time()
  99
 100         # throughput and packet loss from the most recent successful test
 101         successful_pkt_loss = 0.0
 102         for test_value in self.bounds_iterator(LOG):
 103             result, port_samples = self._profile_helper.run_test(pkt_size, duration,
 104                                                                  test_value, self.tolerated_loss)
 105             self.curr_time = time.time()
 106             diff_time = self.curr_time - self.prev_time
 107             self.prev_time = self.curr_time
 108
 109             if result.success:
 110                 LOG.debug("Success! Increasing lower bound")
 111                 self.current_lower = test_value
 112                 successful_pkt_loss = result.pkt_loss
 113                 samples = result.get_samples(pkt_size, successful_pkt_loss, port_samples)
 114                 samples["TxThroughput"] = samples["TxThroughput"] * 1000 * 1000
 115
 116                 # store results with success tag in influxdb
 117                 success_samples = {'Success_' + key: value for key, value in samples.items()}
 118
 119                 success_samples["Success_rx_total"] = int(result.rx_total / diff_time)
 120                 success_samples["Success_tx_total"] = int(result.tx_total / diff_time)
 121                 success_samples["Success_can_be_lost"] = int(result.can_be_lost / diff_time)
 122                 success_samples["Success_drop_total"] = int(result.drop_total / diff_time)
 123                 self.queue.put(success_samples)
 124
 125                 # Store Actual throughput for result samples
 126                 result_samples["Result_Actual_throughput"] = \
 127                     success_samples["Success_RxThroughput"]
 128             else:
 129                 LOG.debug("Failure... Decreasing upper bound")
 130                 self.current_upper = test_value
 131                 samples = result.get_samples(pkt_size, successful_pkt_loss, port_samples)
 132
 133             for k in samples:
 134                     tmp = samples[k]
 135                     if isinstance(tmp, dict):
 136                         for k2 in tmp:
 137                             samples[k][k2] = int(samples[k][k2] / diff_time)
 138
 139             if theor_max_thruput < samples["TxThroughput"]:
 140                 theor_max_thruput = samples['TxThroughput']
 141                 self.queue.put({'theor_max_throughput': theor_max_thruput})
 142
 143             LOG.debug("Collect TG KPIs %s %s", datetime.datetime.now(), samples)
 144             self.queue.put(samples)
 145
 146         result_samples["Result_pktSize"] = pkt_size
 147         result_samples["Result_theor_max_throughput"] = theor_max_thruput/ (1000 * 1000)
 148         self.queue.put(result_samples)