text: # 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
  import datetime
  import time
  
  from yardstick.network_services.traffic_profile.prox_profile import ProxProfile
  from yardstick.network_services import constants
  from yardstick.common import constants as overall_constants
  
  LOG = logging.getLogger(__name__)
  
  STATUS_SUCCESS = "Success"
  STATUS_FAIL = "Failure"
  STATUS_RESULT = "Result"
  STEP_CONFIRM = "Confirm retry"
  STEP_INCREASE_LOWER = "Increase lower"
  STEP_DECREASE_LOWER = "Decrease lower"
  STEP_DECREASE_UPPER = "Decrease upper"
  
  
  class ProxBinSearchProfile(ProxProfile):
      """
      This profile adds a single stream at the beginning of the traffic session
      """
  
      def __init__(self, tp_config):
          super(ProxBinSearchProfile, 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 is_ended(self):
          return self.done.is_set()
  
      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.
  
          theor_max_thruput = 0.0
  
          result_samples = {}
  
          test_data = {
              "test_duration": traffic_gen.scenario_helper.scenario_cfg["runner"]["duration"],
              "test_precision": self.params["traffic_profile"]["test_precision"],
              "tolerated_loss": self.params["traffic_profile"]["tolerated_loss"],
              "duration": duration
          }
          self.prev_time = time.time()
  
          # throughput and packet loss from the most recent successful test
          successful_pkt_loss = 0.0
          line_speed = traffic_gen.scenario_helper.all_options.get(
              "interface_speed_gbps", constants.NIC_GBPS_DEFAULT) * constants.ONE_GIGABIT_IN_BITS
  
          ok_retry = traffic_gen.scenario_helper.scenario_cfg["runner"].get("confirmation", 0)
          for step_id, test_value in enumerate(self.bounds_iterator(LOG)):
              pos_retry = 0
              neg_retry = 0
              total_retry = 0
  
              LOG.info("Checking MAX %s MIN %s TEST %s", self.current_upper,
                       self.lower_bound, test_value)
  
              while (pos_retry <= ok_retry) and (neg_retry <= ok_retry):
  
                  total_retry = total_retry + 1
  
                  result, port_samples = self._profile_helper.run_test(pkt_size, duration,
                                                                       test_value,
                                                                       self.tolerated_loss,
                                                                       line_speed)
  
                  if (total_retry > (ok_retry * 3)) and (ok_retry is not 0):
                      status = STATUS_FAIL
                      next_step = STEP_DECREASE_LOWER
                      successful_pkt_loss = result.pkt_loss
                      self.current_upper = test_value
                      neg_retry = total_retry
                  elif result.success:
                      if (pos_retry < ok_retry) and (ok_retry is not 0):
                          status = STATUS_SUCCESS
                          next_step = STEP_CONFIRM
                          successful_pkt_loss = result.pkt_loss
                          neg_retry = 0
                      else:
                          status = STATUS_SUCCESS
                          next_step = STEP_INCREASE_LOWER
                          self.current_lower = test_value
                          successful_pkt_loss = result.pkt_loss
  
                      pos_retry = pos_retry + 1
  
                  else:
                      if (neg_retry < ok_retry) and (ok_retry is not 0):
                          status = STATUS_FAIL
                          next_step = STEP_CONFIRM
                          pos_retry = 0
                      else:
                          status = STATUS_FAIL
                          next_step = STEP_DECREASE_UPPER
                          self.current_upper = test_value
  
                      neg_retry = neg_retry + 1
  
                  LOG.info(
                      "Status = '%s' Next_Step = '%s'", status, next_step)
  
                  samples = result.get_samples(pkt_size, successful_pkt_loss, port_samples)
  
                  if theor_max_thruput < samples["RequestedTxThroughput"]:
                      theor_max_thruput = samples['RequestedTxThroughput']
                  samples['theor_max_throughput'] = theor_max_thruput
  
                  samples["rx_total"] = int(result.rx_total)
                  samples["tx_total"] = int(result.tx_total)
                  samples["can_be_lost"] = int(result.can_be_lost)
                  samples["drop_total"] = int(result.drop_total)
                  samples["RxThroughput_gbps"] = \
                      (samples["RxThroughput"] / 1000) * ((pkt_size + 20) * 8)
                  samples['Status'] = status
                  samples['Next_Step'] = next_step
                  samples["MAX_Rate"] = self.current_upper
                  samples["MIN_Rate"] = self.current_lower
                  samples["Test_Rate"] = test_value
                  samples["Step_Id"] = step_id
                  samples["Confirmation_Retry"] = total_retry
  
                  samples.update(test_data)
  
                  if status == STATUS_SUCCESS and next_step == STEP_INCREASE_LOWER:
                      # Store success samples for result samples
                      result_samples = samples
  
                  LOG.info(">>>##>>Collect TG KPIs %s %s", datetime.datetime.now(), samples)
  
                  self.queue.put(samples, True, overall_constants.QUEUE_PUT_TIMEOUT)
  
          LOG.info(
              ">>>##>> Result Reached PktSize %s Theor_Max_Thruput %s Actual_throughput %s",
              pkt_size, theor_max_thruput, result_samples.get("RxThroughput", 0.0))
          result_samples["Status"] = STATUS_RESULT
          result_samples["Next_Step"] = ""
          result_samples["Actual_throughput"] = result_samples.get("RxThroughput", 0.0)
          result_samples["theor_max_throughput"] = theor_max_thruput
          self.queue.put(result_samples)
  