Unify IXIA/Trex test cases results

List of changes:
 - Unified naming of all counters reported by IXIA/Trex
 - Removed not valid counters reported by IXIA
 - Added per interface stats reported by Trex
 - Fixed latency calculation for Trex tg

JIRA: YARDSTICK-1592

Change-Id: Ia3d450058f884579f4d331772a8cf6de22146ac3
Signed-off-by: Serhiy Pshyk <serhiyx.pshyk@intel.com>

4 files changed, 101 insertions, 109 deletions

diff --git a/yardstick/network_services/libs/ixia_libs/ixnet/ixnet_api.py b/yardstick/network_services/libs/ixia_libs/ixnet/ixnet_api.py
index ebef7fd9a..89a855480 100644
--- a/yardstick/network_services/libs/ixia_libs/ixnet/ixnet_api.py
+++ b/yardstick/network_services/libs/ixia_libs/ixnet/ixnet_api.py
@@ -94,12 +94,6 @@ class IxNextgen(object):  # pragma: no cover
         "port_name": 'Port Name',
         "Frames_Tx": 'Frames Tx.',
         "Valid_Frames_Rx": 'Valid Frames Rx.',
-        "Frames_Tx_Rate": 'Frames Tx. Rate',
-        "Valid_Frames_Rx_Rate": 'Valid Frames Rx. Rate',
-        "Tx_Rate_Kbps": 'Tx. Rate (Kbps)',
-        "Rx_Rate_Kbps": 'Rx. Rate (Kbps)',
-        "Tx_Rate_Mbps": 'Tx. Rate (Mbps)',
-        "Rx_Rate_Mbps": 'Rx. Rate (Mbps)',
         "Bytes_Tx": 'Bytes Tx.',
         "Bytes_Rx": 'Bytes Rx.'
     }
diff --git a/yardstick/network_services/traffic_profile/ixia_rfc2544.py b/yardstick/network_services/traffic_profile/ixia_rfc2544.py
index 5a9c06aba..ca45b500d 100644
--- a/yardstick/network_services/traffic_profile/ixia_rfc2544.py
+++ b/yardstick/network_services/traffic_profile/ixia_rfc2544.py
@@ -195,13 +195,13 @@ class IXIARFC2544Profile(trex_traffic_profile.TrexProfile):
         num_ifaces = len(samples)
         duration = self.config.duration
         in_packets_sum = sum(
-            [samples[iface]['in_packets'] for iface in samples])
+            [samples[iface]['InPackets'] for iface in samples])
         out_packets_sum = sum(
-            [samples[iface]['out_packets'] for iface in samples])
+            [samples[iface]['OutPackets'] for iface in samples])
         in_bytes_sum = sum(
-            [samples[iface]['in_bytes'] for iface in samples])
+            [samples[iface]['InBytes'] for iface in samples])
         out_bytes_sum = sum(
-            [samples[iface]['out_bytes'] for iface in samples])
+            [samples[iface]['OutBytes'] for iface in samples])
         rx_throughput = round(float(in_packets_sum) / duration, 3)
         tx_throughput = round(float(out_packets_sum) / duration, 3)
         # Rx throughput in Bps
@@ -243,15 +243,10 @@ class IXIARFC2544Profile(trex_traffic_profile.TrexProfile):
                   "completed=%s", tolerance, precision, drop_percent,
                   completed)
 
-        latency_ns_avg = float(
-            sum([samples[iface]['Store-Forward_Avg_latency_ns']
-            for iface in samples])) / num_ifaces
-        latency_ns_min = float(
-            sum([samples[iface]['Store-Forward_Min_latency_ns']
-            for iface in samples])) / num_ifaces
-        latency_ns_max = float(
-            sum([samples[iface]['Store-Forward_Max_latency_ns']
-            for iface in samples])) / num_ifaces
+        latency_ns_avg = float(sum(
+            [samples[iface]['LatencyAvg'] for iface in samples])) / num_ifaces
+        latency_ns_min = min([samples[iface]['LatencyMin'] for iface in samples])
+        latency_ns_max = max([samples[iface]['LatencyMax'] for iface in samples])
 
         samples['Status'] = self.STATUS_FAIL
         if round(drop_percent, precision) <= tolerance:
@@ -262,9 +257,9 @@ class IXIARFC2544Profile(trex_traffic_profile.TrexProfile):
         samples['TxThroughputBps'] = tx_throughput_bps
         samples['RxThroughputBps'] = rx_throughput_bps
         samples['DropPercentage'] = drop_percent
-        samples['latency_ns_avg'] = latency_ns_avg
-        samples['latency_ns_min'] = latency_ns_min
-        samples['latency_ns_max'] = latency_ns_max
+        samples['LatencyAvg'] = latency_ns_avg
+        samples['LatencyMin'] = latency_ns_min
+        samples['LatencyMax'] = latency_ns_max
         samples['Rate'] = last_rate
         samples['PktSize'] = self._get_framesize()
         samples['Iteration'] = self.iteration
@@ -315,10 +310,10 @@ class IXIARFC2544PppoeScenarioProfile(IXIARFC2544Profile):
         drop_percent = 100
         for prio_id in stats:
             prio_flow = stats[prio_id]
-            sum_packet_drop = abs(prio_flow['out_packets'] - prio_flow['in_packets'])
+            sum_packet_drop = abs(prio_flow['OutPackets'] - prio_flow['InPackets'])
             try:
                 drop_percent = round(
-                    (sum_packet_drop / float(prio_flow['out_packets'])) * 100,
+                    (sum_packet_drop / float(prio_flow['OutPackets'])) * 100,
                     self.DROP_PERCENT_ROUND)
             except ZeroDivisionError:
                 LOG.info('No traffic is flowing')
@@ -327,10 +322,10 @@ class IXIARFC2544PppoeScenarioProfile(IXIARFC2544Profile):
 
     def _get_summary_pppoe_subs_counters(self, samples):
         result = {}
-        keys = ['sessions_up',
-                'sessions_down',
-                'sessions_not_started',
-                'sessions_total']
+        keys = ['SessionsUp',
+                'SessionsDown',
+                'SessionsNotStarted',
+                'SessionsTotal']
         for key in keys:
             result[key] = \
                 sum([samples[port][key] for port in samples
@@ -348,13 +343,13 @@ class IXIARFC2544PppoeScenarioProfile(IXIARFC2544Profile):
         priority_stats = self._get_prio_flows_drop_percentage(priority_stats)
         summary_subs_stats = self._get_summary_pppoe_subs_counters(samples)
         in_packets_sum = sum(
-            [samples[iface]['in_packets'] for iface in samples])
+            [samples[iface]['InPackets'] for iface in samples])
         out_packets_sum = sum(
-            [samples[iface]['out_packets'] for iface in samples])
+            [samples[iface]['OutPackets'] for iface in samples])
         in_bytes_sum = sum(
-            [samples[iface]['in_bytes'] for iface in samples])
+            [samples[iface]['InBytes'] for iface in samples])
         out_bytes_sum = sum(
-            [samples[iface]['out_bytes'] for iface in samples])
+            [samples[iface]['OutBytes'] for iface in samples])
         rx_throughput = round(float(in_packets_sum) / duration, 3)
         tx_throughput = round(float(out_packets_sum) / duration, 3)
         # Rx throughput in Bps
@@ -370,25 +365,20 @@ class IXIARFC2544PppoeScenarioProfile(IXIARFC2544Profile):
         except ZeroDivisionError:
             LOG.info('No traffic is flowing')
 
-        latency_ns_avg = float(
-            sum([samples[iface]['Store-Forward_Avg_latency_ns']
-                 for iface in samples])) / num_ifaces
-        latency_ns_min = float(
-            sum([samples[iface]['Store-Forward_Min_latency_ns']
-                 for iface in samples])) / num_ifaces
-        latency_ns_max = float(
-            sum([samples[iface]['Store-Forward_Max_latency_ns']
-                 for iface in samples])) / num_ifaces
+        latency_ns_avg = float(sum(
+            [samples[iface]['LatencyAvg'] for iface in samples])) / num_ifaces
+        latency_ns_min = min([samples[iface]['LatencyMin'] for iface in samples])
+        latency_ns_max = max([samples[iface]['LatencyMax'] for iface in samples])
 
         samples['TxThroughput'] = tx_throughput
         samples['RxThroughput'] = rx_throughput
         samples['TxThroughputBps'] = tx_throughput_bps
         samples['RxThroughputBps'] = rx_throughput_bps
         samples['DropPercentage'] = sum_drop_percent
-        samples['latency_ns_avg'] = latency_ns_avg
-        samples['latency_ns_min'] = latency_ns_min
-        samples['latency_ns_max'] = latency_ns_max
-        samples['priority'] = priority_stats
+        samples['LatencyAvg'] = latency_ns_avg
+        samples['LatencyMin'] = latency_ns_min
+        samples['LatencyMax'] = latency_ns_max
+        samples['Priority'] = priority_stats
         samples['Rate'] = last_rate
         samples['PktSize'] = self._get_framesize()
         samples['Iteration'] = self.iteration
@@ -397,7 +387,7 @@ class IXIARFC2544PppoeScenarioProfile(IXIARFC2544Profile):
         if tc_rfc2544_opts:
             priority = tc_rfc2544_opts.get('priority')
             if priority:
-                drop_percent = samples['priority'][priority]['DropPercentage']
+                drop_percent = samples['Priority'][priority]['DropPercentage']
             else:
                 drop_percent = sum_drop_percent
         else:
diff --git a/yardstick/network_services/traffic_profile/rfc2544.py b/yardstick/network_services/traffic_profile/rfc2544.py
index b12fa9360..aaa491b75 100644
--- a/yardstick/network_services/traffic_profile/rfc2544.py
+++ b/yardstick/network_services/traffic_profile/rfc2544.py
@@ -82,7 +82,6 @@ class RFC2544Profile(trex_traffic_profile.TrexProfile):
         self.rate = self.config.frame_rate
         self.max_rate = self.config.frame_rate
         self.min_rate = 0
-        self.drop_percent_max = 0
 
     def register_generator(self, generator):
         self.generator = generator
@@ -275,7 +274,7 @@ class RFC2544Profile(trex_traffic_profile.TrexProfile):
         return streams
 
     def get_drop_percentage(self, samples, tol_low, tol_high,
-                            correlated_traffic, resolution):
+                            correlated_traffic, resolution): # pylint: disable=unused-argument
         """Calculate the drop percentage and run the traffic"""
         completed = False
         status = self.STATUS_FAIL
@@ -321,26 +320,43 @@ class RFC2544Profile(trex_traffic_profile.TrexProfile):
         LOG.debug("rate=%s, next_rate=%s, resolution=%s, completed=%s",
                   last_rate, self.rate, resolution, completed)
 
-        throughput = rx_rate_fps * 2 if correlated_traffic else rx_rate_fps
-
-        if drop_percent > self.drop_percent_max:
-            self.drop_percent_max = drop_percent
-
-        latency = {port_num: value['latency']
-                   for port_num, value in samples[-1].items()}
-
-        output = {
-            'TxThroughput': tx_rate_fps,
-            'RxThroughput': rx_rate_fps,
-            'RxThroughputBps': round(float(in_bytes) / time_diff, 3),
-            'TxThroughputBps': round(float(out_bytes) / time_diff, 3),
-            'CurrentDropPercentage': drop_percent,
-            'Throughput': throughput,
-            'DropPercentage': self.drop_percent_max,
-            'Rate': last_rate,
-            'Latency': latency,
-            'PktSize': self._get_framesize(),
-            'Iteration': self.iteration,
-            'Status': status
-        }
+        ports = samples[-1].keys()
+        num_ports = len(ports)
+
+        output = {}
+        for port in ports:
+            output[port] = {}
+            first = samples[0][port]
+            last = samples[-1][port]
+            output[port]['InPackets'] = last['in_packets'] - first['in_packets']
+            output[port]['OutPackets'] = last['out_packets'] - first['out_packets']
+            output[port]['InBytes'] = last['in_bytes'] - first['in_bytes']
+            output[port]['OutBytes'] = last['out_bytes'] - first['out_bytes']
+            if self.config.enable_latency:
+                output[port]['LatencyAvg'] = float(sum(
+                    [last['latency'][id]['average'] for id in
+                     last['latency']]) * 1000) / len(last['latency'])
+                output[port]['LatencyMin'] = min(
+                    [last['latency'][id]['total_min'] for id in
+                     last['latency']]) * 1000
+                output[port]['LatencyMax'] = max(
+                    [last['latency'][id]['total_max'] for id in
+                     last['latency']]) * 1000
+
+        output['TxThroughput'] = tx_rate_fps
+        output['RxThroughput'] = rx_rate_fps
+        output['RxThroughputBps'] = round(float(in_bytes) / time_diff, 3)
+        output['TxThroughputBps'] = round(float(out_bytes) / time_diff, 3)
+        output['DropPercentage'] = drop_percent
+        output['Rate'] = last_rate
+        output['PktSize'] = self._get_framesize()
+        output['Iteration'] = self.iteration
+        output['Status'] = status
+
+        if self.config.enable_latency:
+            output['LatencyAvg'] = float(
+                sum([output[port]['LatencyAvg'] for port in ports])) / num_ports
+            output['LatencyMin'] = min([output[port]['LatencyMin'] for port in ports])
+            output['LatencyMax'] = max([output[port]['LatencyMax'] for port in ports])
+
         return completed, output
diff --git a/yardstick/network_services/vnf_generic/vnf/tg_rfc2544_ixia.py b/yardstick/network_services/vnf_generic/vnf/tg_rfc2544_ixia.py
index 5d64a8cba..80812876d 100644
--- a/yardstick/network_services/vnf_generic/vnf/tg_rfc2544_ixia.py
+++ b/yardstick/network_services/vnf_generic/vnf/tg_rfc2544_ixia.py
@@ -80,21 +80,17 @@ class IxiaBasicScenario(object):
                 min_latency = stats['Store-Forward_Min_latency_ns'][port_num]
                 max_latency = stats['Store-Forward_Max_latency_ns'][port_num]
                 samples[port_name] = {
-                    'rx_throughput_kps': float(stats['Rx_Rate_Kbps'][port_num]),
-                    'tx_throughput_kps': float(stats['Tx_Rate_Kbps'][port_num]),
-                    'rx_throughput_mbps': float(stats['Rx_Rate_Mbps'][port_num]),
-                    'tx_throughput_mbps': float(stats['Tx_Rate_Mbps'][port_num]),
                     'RxThroughputBps': float(stats['Bytes_Rx'][port_num]) / duration,
                     'TxThroughputBps': float(stats['Bytes_Tx'][port_num]) / duration,
-                    'in_packets': int(stats['Valid_Frames_Rx'][port_num]),
-                    'out_packets': int(stats['Frames_Tx'][port_num]),
-                    'in_bytes': int(stats['Bytes_Rx'][port_num]),
-                    'out_bytes': int(stats['Bytes_Tx'][port_num]),
+                    'InPackets': int(stats['Valid_Frames_Rx'][port_num]),
+                    'OutPackets': int(stats['Frames_Tx'][port_num]),
+                    'InBytes': int(stats['Bytes_Rx'][port_num]),
+                    'OutBytes': int(stats['Bytes_Tx'][port_num]),
                     'RxThroughput': float(stats['Valid_Frames_Rx'][port_num]) / duration,
                     'TxThroughput': float(stats['Frames_Tx'][port_num]) / duration,
-                    'Store-Forward_Avg_latency_ns': utils.safe_cast(avg_latency, int, 0),
-                    'Store-Forward_Min_latency_ns': utils.safe_cast(min_latency, int, 0),
-                    'Store-Forward_Max_latency_ns': utils.safe_cast(max_latency, int, 0)
+                    'LatencyAvg': utils.safe_cast(avg_latency, int, 0),
+                    'LatencyMin': utils.safe_cast(min_latency, int, 0),
+                    'LatencyMax': utils.safe_cast(max_latency, int, 0)
                 }
             except IndexError:
                 pass
@@ -524,22 +520,22 @@ class IxiaPppoeClientScenario(object):
             avg_latency_ns = sum(
                 [int(flow['Store-Forward_Avg_latency_ns']) for flow in samples
                  if flow['IP_Priority'] == priority]) / prio_flows_num
-            min_latency_ns = sum(
+            min_latency_ns = min(
                 [int(flow['Store-Forward_Min_latency_ns']) for flow in samples
-                 if flow['IP_Priority'] == priority]) / prio_flows_num
-            max_latency_ns = sum(
+                 if flow['IP_Priority'] == priority])
+            max_latency_ns = max(
                 [int(flow['Store-Forward_Max_latency_ns']) for flow in samples
-                 if flow['IP_Priority'] == priority]) / prio_flows_num
+                 if flow['IP_Priority'] == priority])
             tx_throughput = float(tx_frames) / duration
             rx_throughput = float(rx_frames) / duration
             results[priority] = {
-                'in_packets': rx_frames,
-                'out_packets': tx_frames,
+                'InPackets': rx_frames,
+                'OutPackets': tx_frames,
                 'RxThroughput': round(rx_throughput, 3),
                 'TxThroughput': round(tx_throughput, 3),
-                'avg_latency_ns': utils.safe_cast(avg_latency_ns, int, 0),
-                'min_latency_ns': utils.safe_cast(min_latency_ns, int, 0),
-                'max_latency_ns': utils.safe_cast(max_latency_ns, int, 0)
+                'LatencyAvg': utils.safe_cast(avg_latency_ns, int, 0),
+                'LatencyMin': utils.safe_cast(min_latency_ns, int, 0),
+                'LatencyMax': utils.safe_cast(max_latency_ns, int, 0)
             }
         return results
 
@@ -600,38 +596,34 @@ class IxiaPppoeClientScenario(object):
                         flows_stats, flow, 'Store-Forward_Avg_latency_ns'))
                         for flow in port_flow_map[port_num]]) / len(port_flow_map[port_num])
                 min_latency = \
-                    sum([float(self.get_flow_id_data(
+                    min([float(self.get_flow_id_data(
                         flows_stats, flow, 'Store-Forward_Min_latency_ns'))
-                        for flow in port_flow_map[port_num]]) / len(port_flow_map[port_num])
+                        for flow in port_flow_map[port_num]])
                 max_latency = \
-                    sum([float(self.get_flow_id_data(
+                    max([float(self.get_flow_id_data(
                         flows_stats, flow, 'Store-Forward_Max_latency_ns'))
-                        for flow in port_flow_map[port_num]]) / len(port_flow_map[port_num])
+                        for flow in port_flow_map[port_num]])
 
                 samples[port_name] = {
-                    'rx_throughput_kps': float(ports_stats[port_num]['Rx_Rate_Kbps']),
-                    'tx_throughput_kps': float(ports_stats[port_num]['Tx_Rate_Kbps']),
-                    'rx_throughput_mbps': float(ports_stats[port_num]['Rx_Rate_Mbps']),
-                    'tx_throughput_mbps': float(ports_stats[port_num]['Tx_Rate_Mbps']),
                     'RxThroughputBps': float(ports_stats[port_num]['Bytes_Rx']) / duration,
                     'TxThroughputBps': float(ports_stats[port_num]['Bytes_Tx']) / duration,
-                    'in_packets': int(ports_stats[port_num]['Valid_Frames_Rx']),
-                    'out_packets': int(ports_stats[port_num]['Frames_Tx']),
-                    'in_bytes': int(ports_stats[port_num]['Bytes_Rx']),
-                    'out_bytes': int(ports_stats[port_num]['Bytes_Tx']),
+                    'InPackets': int(ports_stats[port_num]['Valid_Frames_Rx']),
+                    'OutPackets': int(ports_stats[port_num]['Frames_Tx']),
+                    'InBytes': int(ports_stats[port_num]['Bytes_Rx']),
+                    'OutBytes': int(ports_stats[port_num]['Bytes_Tx']),
                     'RxThroughput': float(ports_stats[port_num]['Valid_Frames_Rx']) / duration,
                     'TxThroughput': float(ports_stats[port_num]['Frames_Tx']) / duration,
-                    'Store-Forward_Avg_latency_ns': utils.safe_cast(avg_latency, int, 0),
-                    'Store-Forward_Min_latency_ns': utils.safe_cast(min_latency, int, 0),
-                    'Store-Forward_Max_latency_ns': utils.safe_cast(max_latency, int, 0)
+                    'LatencyAvg': utils.safe_cast(avg_latency, int, 0),
+                    'LatencyMin': utils.safe_cast(min_latency, int, 0),
+                    'LatencyMax': utils.safe_cast(max_latency, int, 0)
                 }
 
                 if port_subs_stats:
                     samples[port_name].update(
-                        {'sessions_up': int(port_subs_stats[0]['Sessions_Up']),
-                         'sessions_down': int(port_subs_stats[0]['Sessions_Down']),
-                         'sessions_not_started': int(port_subs_stats[0]['Sessions_Not_Started']),
-                         'sessions_total': int(port_subs_stats[0]['Sessions_Total'])}
+                        {'SessionsUp': int(port_subs_stats[0]['Sessions_Up']),
+                         'SessionsDown': int(port_subs_stats[0]['Sessions_Down']),
+                         'SessionsNotStarted': int(port_subs_stats[0]['Sessions_Not_Started']),
+                         'SessionsTotal': int(port_subs_stats[0]['Sessions_Total'])}
                     )
 
             except IndexError: