traffic_type: RFC2544Profile # defines traffic behavior - constant or look for highest possible throughput
   frame_rate: 100  # pc of linerate
   duration: {{ duration }}
+  enable_latency: False
 
 uplink_0:
   ipv4:
 
   traffic_type: RFC2544Profile # defines traffic behavior - constant or look for highest possible throughput
   frame_rate: 100  # pc of linerate
   duration: {{ duration }}
+  enable_latency: False
 
 uplink_0:
   ipv4:
 
   traffic_type: RFC2544Profile # defines traffic behavior - constant or look for highest possible throughput
   frame_rate: 100  # pc of linerate
   duration: {{ duration }}
+  enable_latency: False
 
 uplink_0:
   ipv4:
 
   traffic_type: RFC2544Profile # defines traffic behavior - constant or look for highest possible throughput
   frame_rate: 100  # pc of linerate
   duration: {{ duration }}
+  enable_latency: False
 
 uplink_0:
   ipv4:
 
   traffic_type : RFC2544Profile # defines traffic behavior - constant or look for highest possible throughput
   frame_rate : 100  # pc of linerate
   duration: {{ duration }}
+  enable_latency: False
 
 uplink_0:
       ipv4:
 
   traffic_type : IXIARFC2544Profile # defines traffic behavior - constant or look for highest possible throughput
   frame_rate : 100  # pc of linerate
   duration: {{ duration }}
+  enable_latency: True
 
 uplink_0:
       ipv4:
 
   traffic_type : IXIARFC2544Profile # defines traffic behavior - constant or look for highest possible throughput
   frame_rate : 100  # pc of linerate
   duration: {{ duration }}
+  enable_latency: True
 
 uplink_0:
       ipv4:
 
   traffic_type : IXIARFC2544Profile # defines traffic behavior - constant or look for highest possible throughput
   frame_rate : 100  # pc of linerate
   injection_time: {{ injection_time }}
+  enable_latency: True
 
 uplink_0:
       ipv4:
 
         self.lower_bound = tprofile.get('lower_bound')
         self.upper_bound = tprofile.get('upper_bound')
         self.step_interval = tprofile.get('step_interval')
+        self.enable_latency = tprofile.get('enable_latency', False)
 
     def _parse_rate(self, rate):
         """Parse traffic profile rate
 
                 ports.append(port_num)
                 port_pg_id.add_port(port_num)
                 profile = self._create_profile(profile_data,
-                                               self.rate, port_pg_id)
+                                               self.rate, port_pg_id,
+                                               self.config.enable_latency)
                 self.generator.client.add_streams(profile, ports=[port_num])
 
         self.generator.client.start(ports=ports,
                                     force=True)
         return ports, port_pg_id
 
-    def _create_profile(self, profile_data, rate, port_pg_id):
+    def _create_profile(self, profile_data, rate, port_pg_id, enable_latency):
         """Create a STL profile (list of streams) for a port"""
         streams = []
         for packet_name in profile_data:
                     get('outer_l2', {}).get('framesize'))
             imix_data = self._create_imix_data(imix)
             self._create_vm(profile_data[packet_name])
-            _streams = self._create_streams(imix_data, rate, port_pg_id)
+            _streams = self._create_streams(imix_data, rate, port_pg_id,
+                                            enable_latency)
             streams.extend(_streams)
         return trex_stl_streams.STLProfile(streams)
 
         return trex_stl_packet_builder_scapy.STLPktBuilder(
             pkt=base_pkt / pad, vm=self.trex_vm)
 
-    def _create_streams(self, imix_data, rate, port_pg_id):
+    def _create_streams(self, imix_data, rate, port_pg_id, enable_latency):
         """Create a list of streams per packet size
 
         The STL TX mode speed of the generated streams will depend on the frame
                              in imix_data.items() if float(weight) > 0):
             packet = self._create_single_packet(size)
             pg_id = port_pg_id.increase_pg_id()
-            stl_flow = trex_stl_streams.STLFlowLatencyStats(pg_id=pg_id)
+            stl_flow = (trex_stl_streams.STLFlowLatencyStats(pg_id=pg_id) if
+                        enable_latency else None)
             mode = trex_stl_streams.STLTXCont(percentage=weight * rate / 100)
             streams.append(trex_stl_client.STLStream(
                 packet=packet, flow_stats=stl_flow, mode=mode))
 
                 mock_create_profile:
             rfc2544_profile.execute_traffic(traffic_generator=mock_generator)
         mock_create_profile.assert_has_calls([
-            mock.call('profile1', rfc2544_profile.rate, mock.ANY),
-            mock.call('profile1', rfc2544_profile.rate, mock.ANY),
-            mock.call('profile2', rfc2544_profile.rate, mock.ANY),
-            mock.call('profile2', rfc2544_profile.rate, mock.ANY)])
+            mock.call('profile1', rfc2544_profile.rate, mock.ANY, False),
+            mock.call('profile1', rfc2544_profile.rate, mock.ANY, False),
+            mock.call('profile2', rfc2544_profile.rate, mock.ANY, False),
+            mock.call('profile2', rfc2544_profile.rate, mock.ANY, False)])
         mock_generator.client.add_streams.assert_has_calls([
             mock.call(mock.ANY, ports=[10]),
             mock.call(mock.ANY, ports=[20]),
                 mock_create_streams:
             mock_create_imix.return_value = 'imix_data'
             mock_create_streams.return_value = ['stream1']
-            rfc2544_profile._create_profile(profile_data, rate, port_pg_id)
+            rfc2544_profile._create_profile(profile_data, rate, port_pg_id,
+                                            True)
 
         mock_create_imix.assert_called_once_with('imix_info')
         mock_create_vm.assert_called_once_with(
             {'outer_l2': {'framesize': 'imix_info'}})
         mock_create_streams.assert_called_once_with('imix_data', 100,
-                                                    port_pg_id)
+                                                    port_pg_id, True)
         mock_stl_profile.assert_called_once_with(['stream1'])
 
     def test__create_imix_data(self):
         rfc2544_profile = rfc2544.RFC2544Profile(self.TRAFFIC_PROFILE)
         with mock.patch.object(rfc2544_profile, '_create_single_packet'):
             output = rfc2544_profile._create_streams(imix_data, rate,
-                                                     port_pg_id)
+                                                     port_pg_id, True)
         self.assertEqual(['stream1', 'stream2'], output)
         mock_latency.assert_has_calls([
             mock.call(pg_id=1), mock.call(pg_id=2)])