Fix build error on CI

Author: KFilipek

unified-runtime/scripts/core/exp-graph.yml

@@ -90,7 +90,7 @@ params:
     desc: "[in] Handle of the queue on which to end graph capture."
   - type: $x_exp_graph_handle_t*
     name: phGraph
-    desc: "[out] Pointer to the handle of the recorded graph object. If $xGraphBeginCaptureIntoGraphExp
+    desc: "[out] Pointer to the handle of the recorded graph object. If $xQueueBeginCaptureIntoGraphExp
           was used to begin the capture, then phGraph will contain the same graph that was passed to it."
   - type: void*
     name: pNext

unified-runtime/source/adapters/level_zero/CMakeLists.txt

@@ -52,6 +52,7 @@ if(UR_BUILD_ADAPTER_L0)
         ${CMAKE_CURRENT_SOURCE_DIR}/sampler.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/image.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/image_common.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/graph.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/helpers/kernel_helpers.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/helpers/memory_helpers.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/helpers/mutable_helpers.cpp

unified-runtime/source/adapters/level_zero/queue.cpp

@@ -930,6 +930,85 @@ ur_result_t urQueueFlush(
   return Queue->executeAllOpenCommandLists();
 }
 
+// Graph capture experimental functions - not yet supported
+ur_result_t urQueueBeginGraphCaptureExp(ur_queue_handle_t hQueue,
+                                        void *pProperties) {
+  std::ignore = hQueue;
+  std::ignore = pProperties;
+  UR_LOG_LEGACY(ERR,
+                logger::LegacyMessage("[UR][L0] {} function not implemented!"),
+                "{} function not implemented!", __FUNCTION__);
+  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
+ur_result_t urQueueBeginCaptureIntoGraphExp(ur_queue_handle_t hQueue,
+                                            ur_exp_graph_handle_t hGraph,
+                                            void *pProperties) {
+  std::ignore = hQueue;
+  std::ignore = hGraph;
+  std::ignore = pProperties;
+  UR_LOG_LEGACY(ERR,
+                logger::LegacyMessage("[UR][L0] {} function not implemented!"),
+                "{} function not implemented!", __FUNCTION__);
+  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
+ur_result_t urQueueEndGraphCaptureExp(ur_queue_handle_t hQueue,
+                                      ur_exp_graph_handle_t *phGraph,
+                                      void *pProperties) {
+  std::ignore = hQueue;
+  std::ignore = pProperties;
+  if (phGraph)
+    *phGraph = nullptr;
+  UR_LOG_LEGACY(ERR,
+                logger::LegacyMessage("[UR][L0] {} function not implemented!"),
+                "{} function not implemented!", __FUNCTION__);
+  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
+ur_result_t urQueueInstantiateGraphExp(ur_exp_graph_handle_t hGraph,
+                                       ur_exp_executable_graph_handle_t *phExecutableGraph,
+                                       void *pProperties) {
+  std::ignore = hGraph;
+  std::ignore = pProperties;
+  if (phExecutableGraph)
+    *phExecutableGraph = nullptr;
+  UR_LOG_LEGACY(ERR,
+                logger::LegacyMessage("[UR][L0] {} function not implemented!"),
+                "{} function not implemented!", __FUNCTION__);
+  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
+ur_result_t urQueueAppendGraphExp(ur_queue_handle_t hQueue,
+                                  ur_exp_executable_graph_handle_t hExecutableGraph,
+                                  void *pProperties,
+                                  ur_event_handle_t *phEvent,
+                                  uint32_t numEventsInWaitList,
+                                  const ur_event_handle_t *phEventWaitList) {
+  std::ignore = hQueue;
+  std::ignore = hExecutableGraph;
+  std::ignore = pProperties;
+  std::ignore = numEventsInWaitList;
+  std::ignore = phEventWaitList;
+  if (phEvent)
+    *phEvent = nullptr;
+  UR_LOG_LEGACY(ERR,
+                logger::LegacyMessage("[UR][L0] {} function not implemented!"),
+                "{} function not implemented!", __FUNCTION__);
+  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
+ur_result_t urQueueIsGraphCaptureEnabledExp(ur_queue_handle_t hQueue,
+                                            bool *pCaptureEnabled) {
+  std::ignore = hQueue;
+  if (pCaptureEnabled)
+    *pCaptureEnabled = false;
+  UR_LOG_LEGACY(ERR,
+                logger::LegacyMessage("[UR][L0] {} function not implemented!"),
+                "{} function not implemented!", __FUNCTION__);
+  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
 } // namespace ur::level_zero
 
 // Configuration of the command-list batching.

unified-runtime/source/adapters/level_zero/v2/api.cpp

@@ -63,4 +63,54 @@ ur_result_t UR_APICALL urUSMPoolTrimToExp(ur_context_handle_t hContext,
   return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
+ur_result_t urGraphCreateExp(ur_context_handle_t hContext,
+                             ur_exp_graph_handle_t *phGraph, void *pNext) {
+  (void)hContext;
+  (void)phGraph;
+  (void)pNext;
+  UR_LOG(ERR, "{} function not implemented!", __FUNCTION__);
+  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
+ur_result_t
+urQueueInstantiateGraphExp(ur_exp_graph_handle_t hGraph,
+                           ur_exp_executable_graph_handle_t *phExecutableGraph,
+                           void *pNext) {
+  (void)hGraph;
+  (void)phExecutableGraph;
+  (void)pNext;
+  UR_LOG(ERR, "{} function not implemented!", __FUNCTION__);
+  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
+ur_result_t urGraphDestroyExp(ur_exp_graph_handle_t hGraph) {
+  (void)hGraph;
+  UR_LOG(ERR, "{} function not implemented!", __FUNCTION__);
+  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
+ur_result_t urGraphExecutableGraphDestroyExp(
+    ur_exp_executable_graph_handle_t hExecutableGraph) {
+  (void)hExecutableGraph;
+  UR_LOG(ERR, "{} function not implemented!", __FUNCTION__);
+  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
+ur_result_t urGraphIsEmptyExp(ur_exp_graph_handle_t hGraph, bool *hResult) {
+  (void)hGraph;
+  if (hResult)
+    *hResult = false;
+  UR_LOG(ERR, "{} function not implemented!", __FUNCTION__);
+  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
+ur_result_t urGraphDumpContentsExp(ur_exp_graph_handle_t hGraph,
+                                   const char *filePath, void *pNext) {
+  (void)hGraph;
+  (void)filePath;
+  (void)pNext;
+  UR_LOG(ERR, "{} function not implemented!", __FUNCTION__);
+  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
 } // namespace ur::level_zero