Add time logging to async segmentation demos

LiteRT-PiperOrigin-RevId: 828961301

Author: gcarranza-1

litert/samples/async_segmentation/BUILD

@@ -71,6 +71,7 @@ cc_binary(
     deps = [
         ":image_processor",
         ":image_utils",
+        ":timing_utils",
         "//litert/cc:litert_api_with_dynamic_runtime",
         "@com_google_absl//absl/strings:string_view",
         "@com_google_absl//absl/time",
@@ -98,6 +99,7 @@ cc_binary(
     deps = [
         ":image_processor",
         ":image_utils",
+        ":timing_utils",
         "//litert/cc:litert_api_with_dynamic_runtime",
         "@com_google_absl//absl/strings:string_view",
         "@com_google_absl//absl/time",
@@ -131,6 +133,7 @@ cc_binary(
     deps = [
         ":image_processor",
         ":image_utils",
+        ":timing_utils",
         "//litert/cc:litert_api_with_dynamic_runtime",
         "@com_google_absl//absl/strings:string_view",
         "@com_google_absl//absl/time",
@@ -157,3 +160,12 @@ cc_library(
         "@com_google_absl//absl/log:absl_check",
     ] + gles_deps(),
 )
+
+cc_library(
+    name = "timing_utils",
+    srcs = ["timing_utils.cc"],
+    hdrs = ["timing_utils.h"],
+    deps = [
+        "@com_google_absl//absl/time",
+    ],
+)

litert/samples/async_segmentation/main_cpu.cc

@@ -21,6 +21,7 @@
 #include <vector>
 
 #include <GLES2/gl2.h>
+#include "absl/time/clock.h"  // from @com_google_absl
 #include "absl/types/span.h"  // from @com_google_absl
 #include "litert/c/litert_common.h"
 #include "litert/cc/litert_compiled_model.h"
@@ -29,6 +30,7 @@
 #include "litert/cc/litert_model.h"
 #include "litert/samples/async_segmentation/image_processor.h"
 #include "litert/samples/async_segmentation/image_utils.h"
+#include "litert/samples/async_segmentation/timing_utils.h"
 
 int main(int argc, char* argv[]) {
   if (argc != 4) {
@@ -74,6 +76,8 @@ int main(int argc, char* argv[]) {
 
   // ================= PRE-PROCESSING =================
   // Load and preprocess the image
+  ProfilingTimestamps profiling_timestamps;
+  profiling_timestamps.load_image_start_time = absl::Now();
   int width_orig = 0, height_orig = 0, channels_file = 0, loaded_channels = 3;
   GLuint tex_id_orig = 0;
   auto img_data_cpu = ImageUtils::LoadImage(input_file, width_orig, height_orig,
@@ -82,6 +86,9 @@ int main(int argc, char* argv[]) {
     std::cerr << "Failed to load image file: " << input_file << std::endl;
     return 1;
   }
+  profiling_timestamps.load_image_end_time =
+      profiling_timestamps.e2e_start_time =
+          profiling_timestamps.pre_process_start_time = absl::Now();
   tex_id_orig = processor.CreateOpenGLTexture(img_data_cpu, width_orig,
                                               height_orig, loaded_channels);
   if (!tex_id_orig) {
@@ -118,9 +125,13 @@ int main(int argc, char* argv[]) {
   LITERT_ABORT_IF_ERROR(
       input_buffers[0].Write(absl::MakeConstSpan(preprocessed_buffer_data)));
 
+  profiling_timestamps.pre_process_end_time =
+      profiling_timestamps.inference_start_time = absl::Now();
   // ================= INFERENCE =================
   // Run inference
   LITERT_ABORT_IF_ERROR(compiled_model.Run(input_buffers, output_buffers));
+  profiling_timestamps.inference_end_time =
+      profiling_timestamps.post_process_start_time = absl::Now();
 
   // ================= POST-PROCESSING =================
   // Post-process the results
@@ -162,6 +173,9 @@ int main(int argc, char* argv[]) {
     return 1;
   }
 
+  profiling_timestamps.post_process_end_time =
+      profiling_timestamps.e2e_end_time =
+          profiling_timestamps.save_image_start_time = absl::Now();
   // Save the output image
   std::vector<unsigned char> final_blended_uchar_data(out_blend_width *
                                                       out_blend_height * 4);
@@ -177,6 +191,9 @@ int main(int argc, char* argv[]) {
   std::cout << "Successfully saved final blended image to " << output_file
             << std::endl;
 
+  profiling_timestamps.save_image_end_time = absl::Now();
+  PrintTiming(profiling_timestamps);
+
   processor.DeleteOpenGLTexture(tex_id_orig);
   processor.DeleteOpenGLBuffer(preprocessed_buffer_id);
   for (GLuint id : mask_buffer_ids) {

litert/samples/async_segmentation/main_gpu.cc

@@ -23,6 +23,7 @@
 #include <vector>
 
 #include <GLES2/gl2.h>
+#include "absl/time/clock.h"  // from @com_google_absl
 #include "absl/types/span.h"  // from @com_google_absl
 #include "litert/c/litert_common.h"
 #include "litert/c/litert_tensor_buffer_types.h"
@@ -39,6 +40,7 @@
 #include "litert/cc/options/litert_gpu_options.h"
 #include "litert/samples/async_segmentation/image_processor.h"
 #include "litert/samples/async_segmentation/image_utils.h"
+#include "litert/samples/async_segmentation/timing_utils.h"
 
 namespace {
 
@@ -182,6 +184,8 @@ int main(int argc, char* argv[]) {
 
   // ================= PRE-PROCESSING =================
   // Load and preprocess the image
+  ProfilingTimestamps profiling_timestamps;
+  profiling_timestamps.load_image_start_time = absl::Now();
   int width_orig = 0, height_orig = 0, channels_file = 0, loaded_channels = 3;
   GLuint tex_id_orig = 0;
   auto img_data_cpu = ImageUtils::LoadImage(input_file, width_orig, height_orig,
@@ -190,6 +194,9 @@ int main(int argc, char* argv[]) {
     std::cerr << "Failed to load image file: " << input_file << std::endl;
     return 1;
   }
+  profiling_timestamps.load_image_end_time =
+      profiling_timestamps.e2e_start_time =
+          profiling_timestamps.pre_process_start_time = absl::Now();
   tex_id_orig = processor.CreateOpenGLTexture(img_data_cpu, width_orig,
                                               height_orig, loaded_channels);
   if (!tex_id_orig) {
@@ -232,12 +239,16 @@ int main(int argc, char* argv[]) {
     LITERT_ABORT_IF_ERROR(
         input_buffers[0].Write(absl::MakeConstSpan(preprocessed_buffer_data)));
   }
+  profiling_timestamps.pre_process_end_time =
+      profiling_timestamps.inference_start_time = absl::Now();
   // ================= INFERENCE =================
   // Run inference
 
   bool async = false;
   LITERT_ABORT_IF_ERROR(
       compiled_model.RunAsync(0, input_buffers, output_buffers, async));
+  profiling_timestamps.inference_end_time =
+      profiling_timestamps.post_process_start_time = absl::Now();
 
   // ================= POST-PROCESSING =================
   // Post-process the results
@@ -291,6 +302,9 @@ int main(int argc, char* argv[]) {
     return 1;
   }
 
+  profiling_timestamps.post_process_end_time =
+      profiling_timestamps.e2e_end_time =
+          profiling_timestamps.save_image_start_time = absl::Now();
   // Save the output image
   std::vector<unsigned char> final_blended_uchar_data(out_blend_width *
                                                       out_blend_height * 4);
@@ -306,6 +320,9 @@ int main(int argc, char* argv[]) {
   std::cout << "Successfully saved final blended image to " << output_file
             << std::endl;
 
+  profiling_timestamps.save_image_end_time = absl::Now();
+  PrintTiming(profiling_timestamps);
+
   processor.DeleteOpenGLTexture(tex_id_orig);
   if (!use_gl_buffers) {
     processor.DeleteOpenGLBuffer(preprocessed_buffer_id);

litert/samples/async_segmentation/main_npu.cc

@@ -23,6 +23,7 @@
 
 #include <GLES2/gl2.h>
 #include "absl/strings/string_view.h"  // from @com_google_absl
+#include "absl/time/clock.h"  // from @com_google_absl
 #include "absl/types/span.h"  // from @com_google_absl
 #include "litert/c/litert_common.h"
 #include "litert/cc/litert_compiled_model.h"
@@ -32,6 +33,7 @@
 #include "litert/cc/litert_options.h"
 #include "litert/samples/async_segmentation/image_processor.h"
 #include "litert/samples/async_segmentation/image_utils.h"
+#include "litert/samples/async_segmentation/timing_utils.h"
 
 int main(int argc, char* argv[]) {
   if (argc != 4) {
@@ -85,6 +87,8 @@ int main(int argc, char* argv[]) {
 
   // ================= PRE-PROCESSING =================
   // Load and preprocess the image
+  ProfilingTimestamps profiling_timestamps;
+  profiling_timestamps.load_image_start_time = absl::Now();
   int width_orig = 0, height_orig = 0, channels_file = 0, loaded_channels = 3;
   GLuint tex_id_orig = 0;
   auto img_data_cpu = ImageUtils::LoadImage(input_file, width_orig, height_orig,
@@ -93,6 +97,9 @@ int main(int argc, char* argv[]) {
     std::cerr << "Failed to load image file: " << input_file << std::endl;
     return 1;
   }
+  profiling_timestamps.load_image_end_time =
+      profiling_timestamps.e2e_start_time =
+          profiling_timestamps.pre_process_start_time = absl::Now();
   tex_id_orig = processor.CreateOpenGLTexture(img_data_cpu, width_orig,
                                               height_orig, loaded_channels);
   if (!tex_id_orig) {
@@ -129,9 +136,13 @@ int main(int argc, char* argv[]) {
   LITERT_ABORT_IF_ERROR(
       input_buffers[0].Write(absl::MakeConstSpan(preprocessed_buffer_data)));
 
+  profiling_timestamps.pre_process_end_time =
+      profiling_timestamps.inference_start_time = absl::Now();
   // ================= INFERENCE =================
   // Run inference
   LITERT_ABORT_IF_ERROR(compiled_model.Run(input_buffers, output_buffers));
+  profiling_timestamps.inference_end_time =
+      profiling_timestamps.post_process_start_time = absl::Now();
 
   // ================= POST-PROCESSING =================
   // Post-process the results
@@ -173,6 +184,9 @@ int main(int argc, char* argv[]) {
     return 1;
   }
 
+  profiling_timestamps.post_process_end_time =
+      profiling_timestamps.e2e_end_time =
+          profiling_timestamps.save_image_start_time = absl::Now();
   // Save the output image
   std::vector<unsigned char> final_blended_uchar_data(out_blend_width *
                                                       out_blend_height * 4);
@@ -188,6 +202,9 @@ int main(int argc, char* argv[]) {
   std::cout << "Successfully saved final blended image to " << output_file
             << std::endl;
 
+  profiling_timestamps.save_image_end_time = absl::Now();
+  PrintTiming(profiling_timestamps);
+
   processor.DeleteOpenGLTexture(tex_id_orig);
   processor.DeleteOpenGLBuffer(preprocessed_buffer_id);
   for (GLuint id : mask_buffer_ids) {

litert/samples/async_segmentation/timing_utils.cc

@@ -0,0 +1,46 @@
+/*
+ * Copyright 2025 The Google AI Edge Authors. All Rights Reserved.
+ *
+ * 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.
+ */
+
+#include "litert/samples/async_segmentation/timing_utils.h"
+
+#include <iostream>
+
+void PrintTiming(const ProfilingTimestamps& profiling_timestamps) {
+  std::cout << "LoadImage took "
+            << profiling_timestamps.load_image_end_time -
+                   profiling_timestamps.load_image_start_time
+            << std::endl;
+  std::cout << "PreprocessInputForSegmentation took "
+            << profiling_timestamps.pre_process_end_time -
+                   profiling_timestamps.pre_process_start_time
+            << std::endl;
+  std::cout << "Inference took "
+            << profiling_timestamps.inference_end_time -
+                   profiling_timestamps.inference_start_time
+            << std::endl;
+  std::cout << "PostprocessSegmentation took "
+            << profiling_timestamps.post_process_end_time -
+                   profiling_timestamps.post_process_start_time
+            << std::endl;
+  std::cout << "SaveImage took "
+            << profiling_timestamps.save_image_end_time -
+                   profiling_timestamps.save_image_start_time
+            << std::endl;
+  std::cout << "E2E (pre + inference + post) took "
+            << profiling_timestamps.e2e_end_time -
+                   profiling_timestamps.e2e_start_time
+            << std::endl;
+}

litert/samples/async_segmentation/timing_utils.h

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2025 The Google AI Edge Authors. All Rights Reserved.
+ *
+ * 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.
+ */
+
+#ifndef THIRD_PARTY_ODML_LITERT_LITERT_SAMPLES_ASYNC_SEGMENTATION_TIMING_UTILS_H_
+#define THIRD_PARTY_ODML_LITERT_LITERT_SAMPLES_ASYNC_SEGMENTATION_TIMING_UTILS_H_
+
+
+#include "absl/time/time.h"  // from @com_google_absl
+
+struct ProfilingTimestamps {
+  absl::Time load_image_start_time;
+  absl::Time load_image_end_time;
+  absl::Time e2e_start_time;
+  absl::Time pre_process_start_time;
+  absl::Time pre_process_end_time;
+  absl::Time inference_start_time;
+  absl::Time inference_end_time;
+  absl::Time post_process_start_time;
+  absl::Time post_process_end_time;
+  absl::Time e2e_end_time;
+  absl::Time save_image_start_time;
+  absl::Time save_image_end_time;
+};
+
+void PrintTiming(const ProfilingTimestamps& profiling_timestamps);
+
+#endif  // THIRD_PARTY_ODML_LITERT_LITERT_SAMPLES_ASYNC_SEGMENTATION_TIMING_UTILS_H_