[Benchmarking-Py] - Release 2.0.1 - Change to perf_counter()

Author: DEKHTIARJonathan

tftrt/benchmarking-python/CHANGELOG.md

@@ -46,6 +46,11 @@ Description of the change
 
 <!-- YOU CAN EDIT FROM HERE -->
 
+## [2.0.1] - 2022.09.30 - @DEKHTIARJonathan
+
+- Change from `time.time()` to `time.perf_counter()` for better time
+measurement. 
+
 ## [2.0.0] - 2022.08.04 - @DEKHTIARJonathan
 
 - Fix for XLA FP16 actually not being applied due to `"min_graph_nodes": -1`

tftrt/benchmarking-python/benchmark_autotuner.py

@@ -32,9 +32,9 @@ def __init__(self, funcs, calls_per_func, skip_n_first):
     def _autotune(self, *arg, **kwargs):
         fn_id = self._call_counter // self._calls_per_func
         try:
-            start_t = time.time()
+            start_t = time.perf_counter()
             output = self._fns[fn_id](*arg, **kwargs)
-            self._timings[fn_id].append(time.time() - start_t)
+            self._timings[fn_id].append(time.perf_counter() - start_t)
         except IndexError:
             print()  # visual spacing
             logging.debug("AutoTuning is over... Collecting timing statistics:")

tftrt/benchmarking-python/benchmark_info.py

@@ -10,7 +10,7 @@
 # The `__version__` number shall be updated everytime core benchmarking files
 # are updated.
 # Please update CHANGELOG.md with a description of what this version changed.
-__version__ = "2.0.0"
+__version__ = "2.0.1"
 
 
 def get_commit_id():

tftrt/benchmarking-python/benchmark_runner.py

@@ -589,9 +589,9 @@ def start_profiling():
 
                     with tracing_ctx('Input Dequeueing'):
                         try:
-                            start_time = time.time()
+                            start_time = time.perf_counter()
                             data_batch = dequeue_batch_fn()
-                            dequeue_times.append(time.time() - start_time)
+                            dequeue_times.append(time.perf_counter() - start_time)
                         except (StopIteration, OutOfRangeError):
                             logging.info("[Exiting] Reached end of dataset ...")
                             break
@@ -600,14 +600,14 @@ def start_profiling():
                         x, y = self.preprocess_model_inputs(data_batch)
 
                     with tracing_ctx('Inputs MemcpyHtoD'):
-                        start_time = time.time()
+                        start_time = time.perf_counter()
                         x = force_data_on_gpu_fn(x)
-                        memcopy_times.append(time.time() - start_time)
+                        memcopy_times.append(time.perf_counter() - start_time)
 
                     with tracing_ctx('GPU Inference'):
-                        start_time = time.time()
+                        start_time = time.perf_counter()
                         y_pred = infer_batch(x)
-                        iter_times.append(time.time() - start_time)
+                        iter_times.append(time.perf_counter() - start_time)
 
                 if not self._args.debug_performance:
                     log_step(

tftrt/benchmarking-python/benchmark_utils.py

@@ -68,9 +68,9 @@ def timed_section(msg, activate=True, start_end_mode=True):
         if start_end_mode:
             logging.info(f"[START] {msg} ...")
 
-        start_time = time.time()
+        start_time = time.perf_counter()
         yield
-        total_time = time.time() - start_time
+        total_time = time.perf_counter() - start_time
 
         if start_end_mode:
             logging.info(f"[END] {msg} - Duration: {total_time:.1f}s")

tftrt/benchmarking-python/template/infer.py

@@ -137,9 +137,9 @@ def evaluate_model(self, predictions, expected, bypass_data_to_eval):
     # let's say transforming a list into a dict() or reverse
     batch = preprocess_model_inputs(batch)
 
-    start_t = time.time()
+    start_t = time.perf_counter()
     outputs = model_fn(batch)
-    print(f"Inference Time: {(time.time() - start_t)*1000:.1f}ms")  # 0.001
+    print(f"Inference Time: {(time.perf_counter() - start_t)*1000:.1f}ms")  # 0.001
 
     ## post my outputs to "measure accuracy"
     ## note: we skip that

tftrt/blog_posts/Leveraging TensorFlow-TensorRT integration for Low latency Inference/tf2_inference.py

@@ -132,10 +132,10 @@ def calibration_input_fn():
         for step in range(1, INFERENCE_STEPS + 1):
             if step % 100 == 0:
                 print("Processing step: %04d ..." % step)
-            start_t = time.time()
+            start_t = time.perf_counter()
             probs = infer(features)[output_tensorname]
             inferred_class = tf.math.argmax(probs).numpy()
-            step_time = time.time() - start_t
+            step_time = time.perf_counter() - start_t
             if step >= WARMUP_STEPS:
                 step_times.append(step_time)
     except tf.errors.OutOfRangeError: