[VitisAI] pass base timestamp for vitisai profiling (microsoft#27808)

### Description
Pass base timestamp for vitisai profiling

Notify EP that profiling has started with the base timestamp (in
nanoseconds since epoch)
The VitisAI EP can use this to:
1. Calculate relative timestamps (event_ts - base_ts) for the profiling
timeline
2. Store the absolute base timestamp if needed for other purposes



### Motivation and Context
Due to onnxruntime default profiling json file just have the offset
timestamp, it doesn't provider the base timestamp for VitisAI EP, To
combine the VaitisAI timeline profiling info and the onnxruntime default
profiling json file info, We need pass the timestamp for VitisAI EP.

---------

Signed-off-by: Andrew Luo <junpengl@amd.com>
Co-authored-by: Andrew Luo <junpengl@amd.com>

Author: andrew0917

onnxruntime/core/providers/vitisai/imp/global_api.cc

@@ -93,9 +93,16 @@ struct OrtVitisAIEpAPI {
       const std::vector<std::unique_ptr<vaip_core::ExecutionProvider>>& eps,
       const char* const* keys,
       const char* const* values, size_t kv_len) = nullptr;
+  void (*profiler_start)(uint64_t profiling_start_time_us) = nullptr;
+  void (*profiler_stop)() = nullptr;
+  // v1: Original 5-element EventInfo
   void (*profiler_collect)(
       std::vector<EventInfo>& api_events,
       std::vector<EventInfo>& kernel_events) = nullptr;
+  // v2: Extended 6-element EventInfoV2 with args
+  void (*profiler_collect_v2)(
+      std::vector<EventInfoV2>& api_events,
+      std::vector<EventInfoV2>& kernel_events) = nullptr;
   const char* (*get_compiled_model_compatibility_info)(
       const std::vector<std::unique_ptr<vaip_core::ExecutionProvider>>* eps,
       const void* graph_viewer) = nullptr;
@@ -144,7 +151,10 @@ struct OrtVitisAIEpAPI {
     }
     std::ignore = env.GetSymbolFromLibrary(handle_, "vaip_get_version",
                                            (void**)&vaip_get_version);
+    std::ignore = env.GetSymbolFromLibrary(handle_, "profiler_start", (void**)&profiler_start);
+    std::ignore = env.GetSymbolFromLibrary(handle_, "profiler_stop", (void**)&profiler_stop);
     std::ignore = env.GetSymbolFromLibrary(handle_, "profiler_collect", (void**)&profiler_collect);
+    std::ignore = env.GetSymbolFromLibrary(handle_, "profiler_collect_v2", (void**)&profiler_collect_v2);
     std::ignore = env.GetSymbolFromLibrary(handle_, "get_compiled_model_compatibility_info", (void**)&get_compiled_model_compatibility_info);
     std::ignore = env.GetSymbolFromLibrary(handle_, "validate_compiled_model_compatibility_info", (void**)&validate_compiled_model_compatibility_info);
     ORT_THROW_IF_ERROR(env.GetSymbolFromLibrary(handle_, "create_ep_context_nodes", (void**)&create_ep_context_nodes));
@@ -176,13 +186,16 @@ struct OrtVitisAIEpAPI {
       compile_onnx_model_vitisai_ep_v4 = nullptr;
       vaip_execution_provider_deletor = [](std::vector<std::unique_ptr<vaip_core::ExecutionProvider>>* p) noexcept { delete p; };
       vaip_get_version = nullptr;
-      profiler_collect = nullptr;
       get_compiled_model_compatibility_info = nullptr;
       validate_compiled_model_compatibility_info = nullptr;
       create_ep_context_nodes = nullptr;
       vitisai_ep_on_run_start = nullptr;
       vitisai_ep_set_ep_dynamic_options = nullptr;
       deinitialize_onnxruntime_vitisai_ep = nullptr;
+      profiler_start = nullptr;
+      profiler_stop = nullptr;
+      profiler_collect = nullptr;
+      profiler_collect_v2 = nullptr;
     }
   }
 
@@ -197,6 +210,18 @@ static vaip_core::OrtApiForVaip the_global_api;
 std::shared_ptr<KernelRegistry> get_kernel_registry_vitisaiep() { return s_kernel_registry_vitisaiep; }
 const std::vector<OrtCustomOpDomain*>& get_domains_vitisaiep() { return s_domains_vitisaiep; }
 
+void profiler_start(uint64_t profiling_start_time_us) {
+  if (s_library_vitisaiep.profiler_start) {
+    s_library_vitisaiep.profiler_start(profiling_start_time_us);
+  }
+}
+
+void profiler_stop() {
+  if (s_library_vitisaiep.profiler_stop) {
+    s_library_vitisaiep.profiler_stop();
+  }
+}
+
 void profiler_collect(
     std::vector<EventInfo>& api_events,
     std::vector<EventInfo>& kernel_events) {
@@ -205,6 +230,16 @@ void profiler_collect(
   }
 }
 
+bool profiler_collect_v2(
+    std::vector<EventInfoV2>& api_events,
+    std::vector<EventInfoV2>& kernel_events) {
+  if (s_library_vitisaiep.profiler_collect_v2) {
+    s_library_vitisaiep.profiler_collect_v2(api_events, kernel_events);
+    return true;
+  }
+  return false;
+}
+
 std::string get_compiled_model_compatibility_info(
     const std::vector<std::unique_ptr<vaip_core::ExecutionProvider>>& eps,
     const onnxruntime::GraphViewer& graph_viewer) {

onnxruntime/core/providers/vitisai/include/vaip/global_api.h

@@ -27,10 +27,19 @@ int vitisai_ep_set_ep_dynamic_options(
     const std::vector<std::unique_ptr<vaip_core::ExecutionProvider>>& eps,
     const char* const* keys,
     const char* const* values, size_t kv_len);
+
+// Notify EP that profiling has started with the base timestamp (in microseconds since epoch)
+// The EP can use this to:
+// 1. Calculate relative timestamps (event_ts - base_ts) for the profiling timeline
+// 2. Store the absolute base timestamp if needed for other purposes
+void profiler_start(uint64_t profiling_start_time_us);
+
+// Notify EP that profiling has stopped
+void profiler_stop();
+
 /**
- * Replace EventRecord with std::tuple<std::string, int ,int, long long, long long>,
- * because EventRecord is defined in profiler_common.h which is used inside onnxruntime.
- * However, profiler_collect function will call vitis ep which can't include profiler_common.h.
+ * EventInfo: Original 5-element tuple (v1 API)
+ * Kept for backward compatibility with older vaip versions.
  */
 using EventInfo = std::tuple<
     std::string,  // name
@@ -42,6 +51,28 @@ using EventInfo = std::tuple<
 void profiler_collect(
     std::vector<EventInfo>& api_events,
     std::vector<EventInfo>& kernel_events);
+
+/**
+ * EventInfoV2: Extended 6-element tuple with args map (v2 API)
+ * 6th element: args map for extended metadata (subgraph_name, flow_type, kernel_idx)
+ */
+using EventInfoV2 = std::tuple<
+    std::string,                                  // name
+    int,                                          // pid
+    int,                                          // tid
+    long long,                                    // timestamp
+    long long,                                    // duration
+    std::unordered_map<std::string, std::string>  // args
+    >;
+
+// v2 API
+// Returns true if the v2 collector symbol was present in the loaded VAIP
+// library (i.e. the EP is v2-capable). Returns false if the symbol is not
+// available, in which case callers should fall back to profiler_collect (v1).
+bool profiler_collect_v2(
+    std::vector<EventInfoV2>& api_events,
+    std::vector<EventInfoV2>& kernel_events);
+
 std::unique_ptr<onnxruntime::IExecutionProvider>
 CreateExecutionProviderFromAnotherEp(const std::string& lib, const OrtSessionOptions& session_options,
                                      std::unordered_map<std::string, std::string>& provider_options);

onnxruntime/core/providers/vitisai/vitisai_profiler.cc

@@ -11,37 +11,82 @@ namespace profiling {
 #if defined(USE_VITISAI)
 
 bool VitisaiProfiler::StartProfiling(TimePoint tp) {
+  // Notify VAIP EP that profiling has started with base timestamp
+  profiler_start(std::chrono::duration_cast<std::chrono::microseconds>(
+                     tp.time_since_epoch())
+                     .count());
   return true;
 }
 
 void VitisaiProfiler::EndProfiling(TimePoint tp, Events& events) {
+  // Notify VAIP EP that profiling has stopped
+  // Contract: the VAIP EP must preserve any pending/buffered event data after
+  // profiler_stop() returns, so that the subsequent profiler_collect[_v2]()
+  // call below can still retrieve the full set of recorded events. The EP is
+  // expected to release that buffered data only after collection completes
+  // (or on the next profiler_start()).
+  profiler_stop();
+
   auto time_point =
       std::chrono::duration_cast<std::chrono::microseconds>(tp.time_since_epoch()).count();
 
-  std::vector<EventInfo> api_events;
-  std::vector<EventInfo> kernel_events;
-  profiler_collect(api_events, kernel_events);
+  // Try v2 first
+  // Use the free function wrappers which internally null-check the pointers.
+  std::vector<EventInfoV2> api_events_v2;
+  std::vector<EventInfoV2> kernel_events_v2;
+  const bool v2_available = profiler_collect_v2(api_events_v2, kernel_events_v2);
 
-  InlinedHashMap<std::string, std::string> event_args;
+  if (v2_available) {
+    for (auto& a : api_events_v2) {
+      auto& src_args = std::get<5>(a);
+      decltype(EventRecord::args) args(src_args.begin(), src_args.end());
+      events.emplace_back(EventCategory::API_EVENT,
+                          std::get<1>(a),
+                          std::get<2>(a),
+                          std::get<0>(a),
+                          std::get<3>(a) - time_point,
+                          std::get<4>(a),
+                          std::move(args));
+    }
 
-  for (auto& a : api_events) {
-    events.emplace_back(EventCategory::API_EVENT,
-                        std::get<1>(a),               // pid
-                        std::get<2>(a),               // tid
-                        std::get<0>(a),               // name
-                        std::get<3>(a) - time_point,  // timestamp
-                        std::get<4>(a),               // duration
-                        event_args);
-  }
+    for (auto& k : kernel_events_v2) {
+      auto& src_args = std::get<5>(k);
+      decltype(EventRecord::args) args(src_args.begin(), src_args.end());
+      events.emplace_back(EventCategory::KERNEL_EVENT,
+                          std::get<1>(k),
+                          std::get<2>(k),
+                          std::get<0>(k),
+                          std::get<3>(k) - time_point,
+                          std::get<4>(k),
+                          std::move(args));
+    }
+  } else {
+    // Fall back to v1 API
+    std::vector<EventInfo> api_events;
+    std::vector<EventInfo> kernel_events;
+    profiler_collect(api_events, kernel_events);
+
+    decltype(EventRecord::args) event_args;
+
+    for (auto& a : api_events) {
+      events.emplace_back(EventCategory::API_EVENT,
+                          std::get<1>(a),
+                          std::get<2>(a),
+                          std::get<0>(a),
+                          std::get<3>(a) - time_point,
+                          std::get<4>(a),
+                          event_args);
+    }
 
-  for (auto& k : kernel_events) {
-    events.emplace_back(EventCategory::KERNEL_EVENT,
-                        std::get<1>(k),
-                        std::get<2>(k),
-                        std::get<0>(k),
-                        std::get<3>(k) - time_point,
-                        std::get<4>(k),
-                        event_args);
+    for (auto& k : kernel_events) {
+      events.emplace_back(EventCategory::KERNEL_EVENT,
+                          std::get<1>(k),
+                          std::get<2>(k),
+                          std::get<0>(k),
+                          std::get<3>(k) - time_point,
+                          std::get<4>(k),
+                          event_args);
+    }
   }
 }