From 89d5832fa622a1efff889f2f21cd5d387e9166b2 Mon Sep 17 00:00:00 2001 From: Igor Chorazewicz Date: Thu, 23 Mar 2023 18:13:48 +0000 Subject: [PATCH] [ur] unify usm_advice naming --- include/ur.py | 28 ++++----- include/ur_api.h | 52 ++++++++-------- include/ur_ddi.h | 8 +-- scripts/core/enqueue.yml | 4 +- scripts/core/event.yml | 4 +- scripts/core/registry.yml | 4 +- scripts/core/usm.yml | 10 +-- source/drivers/null/ur_nullddi.cpp | 14 ++--- source/loader/layers/tracing/ur_trcddi.cpp | 28 ++++----- source/loader/layers/validation/ur_valddi.cpp | 18 +++--- source/loader/ur_ldrddi.cpp | 14 ++--- source/loader/ur_libapi.cpp | 12 ++-- source/ur_api.cpp | 6 +- test/conformance/enqueue/CMakeLists.txt | 2 +- .../enqueue/urEnqueueUSMAdvise.cpp | 60 ++++++++++++++++++ .../enqueue/urEnqueueUSMMemAdvise.cpp | 61 ------------------- test/conformance/usm/urUSMSharedAlloc.cpp | 2 +- 17 files changed, 163 insertions(+), 164 deletions(-) create mode 100644 test/conformance/enqueue/urEnqueueUSMAdvise.cpp delete mode 100644 test/conformance/enqueue/urEnqueueUSMMemAdvise.cpp diff --git a/include/ur.py b/include/ur.py index a60397967e..6b008e0e4f 100644 --- a/include/ur.py +++ b/include/ur.py @@ -984,20 +984,20 @@ def __str__(self): ############################################################################### ## @brief USM memory advice -class ur_mem_advice_v(IntEnum): +class ur_usm_advice_v(IntEnum): DEFAULT = 0 ## The USM memory advice is default SET_READ_MOSTLY = 1 ## Hint that memory will be read from frequently and written to rarely - CLEAR_READ_MOSTLY = 2 ## Removes the affect of ::::UR_MEM_ADVICE_SET_READ_MOSTLY + CLEAR_READ_MOSTLY = 2 ## Removes the affect of ::::UR_USM_ADVICE_SET_READ_MOSTLY SET_PREFERRED_LOCATION = 3 ## Hint that the preferred memory location is the specified device - CLEAR_PREFERRED_LOCATION = 4 ## Removes the affect of ::::UR_MEM_ADVICE_SET_PREFERRED_LOCATION + CLEAR_PREFERRED_LOCATION = 4 ## Removes the affect of ::::UR_USM_ADVICE_SET_PREFERRED_LOCATION SET_NON_ATOMIC_MOSTLY = 5 ## Hints that memory will mostly be accessed non-atomically - CLEAR_NON_ATOMIC_MOSTLY = 6 ## Removes the affect of ::::UR_MEM_ADVICE_SET_NON_ATOMIC_MOSTLY + CLEAR_NON_ATOMIC_MOSTLY = 6 ## Removes the affect of ::::UR_USM_ADVICE_SET_NON_ATOMIC_MOSTLY BIAS_CACHED = 7 ## Hints that memory should be cached BIAS_UNCACHED = 8 ## Hints that memory should be not be cached -class ur_mem_advice_t(c_int): +class ur_usm_advice_t(c_int): def __str__(self): - return str(ur_mem_advice_v(self.value)) + return str(ur_usm_advice_v(self.value)) ############################################################################### @@ -1012,7 +1012,7 @@ class ur_usm_desc_t(Structure): ("stype", ur_structure_type_t), ## [in] type of this structure, must be ::UR_STRUCTURE_TYPE_USM_DESC ("pNext", c_void_p), ## [in][optional] pointer to extension-specific structure ("flags", ur_usm_flags_t), ## [in] memory allocation flags. - ("hints", ur_mem_advice_t), ## [in] Memory advice hints + ("hints", ur_usm_advice_t), ## [in] Memory advice hints ("align", c_ulong) ## [in] memory advice hints. ] @@ -1314,7 +1314,7 @@ class ur_command_v(IntEnum): USM_FILL = 17 ## Event created by ::urEnqueueUSMFill USM_MEMCPY = 18 ## Event created by ::urEnqueueUSMMemcpy USM_PREFETCH = 19 ## Event created by ::urEnqueueUSMPrefetch - USM_MEM_ADVISE = 20 ## Event created by ::urEnqueueUSMMemAdvise + USM_ADVISE = 20 ## Event created by ::urEnqueueUSMAdvise USM_FILL_2D = 21 ## Event created by ::urEnqueueUSMFill2D USM_MEMCPY_2D = 22 ## Event created by ::urEnqueueUSMMemcpy2D DEVICE_GLOBAL_VARIABLE_WRITE = 23 ## Event created by ::urEnqueueDeviceGlobalVariableWrite @@ -1431,7 +1431,7 @@ class ur_function_v(IntEnum): ENQUEUE_USM_FILL = 32 ## Enumerator for ::urEnqueueUSMFill ENQUEUE_USM_MEMCPY = 33 ## Enumerator for ::urEnqueueUSMMemcpy ENQUEUE_USM_PREFETCH = 34 ## Enumerator for ::urEnqueueUSMPrefetch - ENQUEUE_USM_MEM_ADVISE = 35 ## Enumerator for ::urEnqueueUSMMemAdvise + ENQUEUE_USM_ADVISE = 35 ## Enumerator for ::urEnqueueUSMAdvise ENQUEUE_USM_FILL2_D = 36 ## Enumerator for ::urEnqueueUSMFill2D ENQUEUE_USM_MEMCPY2_D = 37 ## Enumerator for ::urEnqueueUSMMemcpy2D ENQUEUE_DEVICE_GLOBAL_VARIABLE_WRITE = 38 ## Enumerator for ::urEnqueueDeviceGlobalVariableWrite @@ -2220,11 +2220,11 @@ class ur_mem_dditable_t(Structure): _urEnqueueUSMPrefetch_t = CFUNCTYPE( ur_result_t, ur_queue_handle_t, c_void_p, c_size_t, ur_usm_migration_flags_t, c_ulong, POINTER(ur_event_handle_t), POINTER(ur_event_handle_t) ) ############################################################################### -## @brief Function-pointer for urEnqueueUSMMemAdvise +## @brief Function-pointer for urEnqueueUSMAdvise if __use_win_types: - _urEnqueueUSMMemAdvise_t = WINFUNCTYPE( ur_result_t, ur_queue_handle_t, c_void_p, c_size_t, ur_mem_advice_t, POINTER(ur_event_handle_t) ) + _urEnqueueUSMAdvise_t = WINFUNCTYPE( ur_result_t, ur_queue_handle_t, c_void_p, c_size_t, ur_usm_advice_t, POINTER(ur_event_handle_t) ) else: - _urEnqueueUSMMemAdvise_t = CFUNCTYPE( ur_result_t, ur_queue_handle_t, c_void_p, c_size_t, ur_mem_advice_t, POINTER(ur_event_handle_t) ) + _urEnqueueUSMAdvise_t = CFUNCTYPE( ur_result_t, ur_queue_handle_t, c_void_p, c_size_t, ur_usm_advice_t, POINTER(ur_event_handle_t) ) ############################################################################### ## @brief Function-pointer for urEnqueueUSMFill2D @@ -2277,7 +2277,7 @@ class ur_enqueue_dditable_t(Structure): ("pfnUSMFill", c_void_p), ## _urEnqueueUSMFill_t ("pfnUSMMemcpy", c_void_p), ## _urEnqueueUSMMemcpy_t ("pfnUSMPrefetch", c_void_p), ## _urEnqueueUSMPrefetch_t - ("pfnUSMMemAdvise", c_void_p), ## _urEnqueueUSMMemAdvise_t + ("pfnUSMAdvise", c_void_p), ## _urEnqueueUSMAdvise_t ("pfnUSMFill2D", c_void_p), ## _urEnqueueUSMFill2D_t ("pfnUSMMemcpy2D", c_void_p), ## _urEnqueueUSMMemcpy2D_t ("pfnDeviceGlobalVariableWrite", c_void_p), ## _urEnqueueDeviceGlobalVariableWrite_t @@ -2713,7 +2713,7 @@ def __init__(self, version : ur_api_version_t): self.urEnqueueUSMFill = _urEnqueueUSMFill_t(self.__dditable.Enqueue.pfnUSMFill) self.urEnqueueUSMMemcpy = _urEnqueueUSMMemcpy_t(self.__dditable.Enqueue.pfnUSMMemcpy) self.urEnqueueUSMPrefetch = _urEnqueueUSMPrefetch_t(self.__dditable.Enqueue.pfnUSMPrefetch) - self.urEnqueueUSMMemAdvise = _urEnqueueUSMMemAdvise_t(self.__dditable.Enqueue.pfnUSMMemAdvise) + self.urEnqueueUSMAdvise = _urEnqueueUSMAdvise_t(self.__dditable.Enqueue.pfnUSMAdvise) self.urEnqueueUSMFill2D = _urEnqueueUSMFill2D_t(self.__dditable.Enqueue.pfnUSMFill2D) self.urEnqueueUSMMemcpy2D = _urEnqueueUSMMemcpy2D_t(self.__dditable.Enqueue.pfnUSMMemcpy2D) self.urEnqueueDeviceGlobalVariableWrite = _urEnqueueDeviceGlobalVariableWrite_t(self.__dditable.Enqueue.pfnDeviceGlobalVariableWrite) diff --git a/include/ur_api.h b/include/ur_api.h index 969e44bbb2..0955ab0808 100644 --- a/include/ur_api.h +++ b/include/ur_api.h @@ -2192,21 +2192,21 @@ typedef enum ur_usm_alloc_info_t { /////////////////////////////////////////////////////////////////////////////// /// @brief USM memory advice -typedef enum ur_mem_advice_t { - UR_MEM_ADVICE_DEFAULT = 0, ///< The USM memory advice is default - UR_MEM_ADVICE_SET_READ_MOSTLY = 1, ///< Hint that memory will be read from frequently and written to rarely - UR_MEM_ADVICE_CLEAR_READ_MOSTLY = 2, ///< Removes the affect of ::::UR_MEM_ADVICE_SET_READ_MOSTLY - UR_MEM_ADVICE_SET_PREFERRED_LOCATION = 3, ///< Hint that the preferred memory location is the specified device - UR_MEM_ADVICE_CLEAR_PREFERRED_LOCATION = 4, ///< Removes the affect of ::::UR_MEM_ADVICE_SET_PREFERRED_LOCATION - UR_MEM_ADVICE_SET_NON_ATOMIC_MOSTLY = 5, ///< Hints that memory will mostly be accessed non-atomically - UR_MEM_ADVICE_CLEAR_NON_ATOMIC_MOSTLY = 6, ///< Removes the affect of ::::UR_MEM_ADVICE_SET_NON_ATOMIC_MOSTLY - UR_MEM_ADVICE_BIAS_CACHED = 7, ///< Hints that memory should be cached - UR_MEM_ADVICE_BIAS_UNCACHED = 8, ///< Hints that memory should be not be cached +typedef enum ur_usm_advice_t { + UR_USM_ADVICE_DEFAULT = 0, ///< The USM memory advice is default + UR_USM_ADVICE_SET_READ_MOSTLY = 1, ///< Hint that memory will be read from frequently and written to rarely + UR_USM_ADVICE_CLEAR_READ_MOSTLY = 2, ///< Removes the affect of ::::UR_USM_ADVICE_SET_READ_MOSTLY + UR_USM_ADVICE_SET_PREFERRED_LOCATION = 3, ///< Hint that the preferred memory location is the specified device + UR_USM_ADVICE_CLEAR_PREFERRED_LOCATION = 4, ///< Removes the affect of ::::UR_USM_ADVICE_SET_PREFERRED_LOCATION + UR_USM_ADVICE_SET_NON_ATOMIC_MOSTLY = 5, ///< Hints that memory will mostly be accessed non-atomically + UR_USM_ADVICE_CLEAR_NON_ATOMIC_MOSTLY = 6, ///< Removes the affect of ::::UR_USM_ADVICE_SET_NON_ATOMIC_MOSTLY + UR_USM_ADVICE_BIAS_CACHED = 7, ///< Hints that memory should be cached + UR_USM_ADVICE_BIAS_UNCACHED = 8, ///< Hints that memory should be not be cached /// @cond - UR_MEM_ADVICE_FORCE_UINT32 = 0x7fffffff + UR_USM_ADVICE_FORCE_UINT32 = 0x7fffffff /// @endcond -} ur_mem_advice_t; +} ur_usm_advice_t; /////////////////////////////////////////////////////////////////////////////// /// @brief Handle of USM pool @@ -2218,7 +2218,7 @@ typedef struct ur_usm_desc_t { ur_structure_type_t stype; ///< [in] type of this structure, must be ::UR_STRUCTURE_TYPE_USM_DESC const void *pNext; ///< [in][optional] pointer to extension-specific structure ur_usm_flags_t flags; ///< [in] memory allocation flags. - ur_mem_advice_t hints; ///< [in] Memory advice hints + ur_usm_advice_t hints; ///< [in] Memory advice hints uint32_t align; ///< [in] memory advice hints. } ur_usm_desc_t; @@ -3783,7 +3783,7 @@ typedef enum ur_command_t { UR_COMMAND_USM_FILL = 17, ///< Event created by ::urEnqueueUSMFill UR_COMMAND_USM_MEMCPY = 18, ///< Event created by ::urEnqueueUSMMemcpy UR_COMMAND_USM_PREFETCH = 19, ///< Event created by ::urEnqueueUSMPrefetch - UR_COMMAND_USM_MEM_ADVISE = 20, ///< Event created by ::urEnqueueUSMMemAdvise + UR_COMMAND_USM_ADVISE = 20, ///< Event created by ::urEnqueueUSMAdvise UR_COMMAND_USM_FILL_2D = 21, ///< Event created by ::urEnqueueUSMFill2D UR_COMMAND_USM_MEMCPY_2D = 22, ///< Event created by ::urEnqueueUSMMemcpy2D UR_COMMAND_DEVICE_GLOBAL_VARIABLE_WRITE = 23, ///< Event created by ::urEnqueueDeviceGlobalVariableWrite @@ -4115,7 +4115,7 @@ typedef enum ur_function_t { UR_FUNCTION_ENQUEUE_USM_FILL = 32, ///< Enumerator for ::urEnqueueUSMFill UR_FUNCTION_ENQUEUE_USM_MEMCPY = 33, ///< Enumerator for ::urEnqueueUSMMemcpy UR_FUNCTION_ENQUEUE_USM_PREFETCH = 34, ///< Enumerator for ::urEnqueueUSMPrefetch - UR_FUNCTION_ENQUEUE_USM_MEM_ADVISE = 35, ///< Enumerator for ::urEnqueueUSMMemAdvise + UR_FUNCTION_ENQUEUE_USM_ADVISE = 35, ///< Enumerator for ::urEnqueueUSMAdvise UR_FUNCTION_ENQUEUE_USM_FILL2_D = 36, ///< Enumerator for ::urEnqueueUSMFill2D UR_FUNCTION_ENQUEUE_USM_MEMCPY2_D = 37, ///< Enumerator for ::urEnqueueUSMMemcpy2D UR_FUNCTION_ENQUEUE_DEVICE_GLOBAL_VARIABLE_WRITE = 38, ///< Enumerator for ::urEnqueueDeviceGlobalVariableWrite @@ -5117,7 +5117,7 @@ urEnqueueUSMPrefetch( /// - ::UR_RESULT_ERROR_INVALID_NULL_POINTER /// + `NULL == pMem` /// - ::UR_RESULT_ERROR_INVALID_ENUMERATION -/// + `::UR_MEM_ADVICE_BIAS_UNCACHED < advice` +/// + `::UR_USM_ADVICE_BIAS_UNCACHED < advice` /// - ::UR_RESULT_ERROR_INVALID_QUEUE /// - ::UR_RESULT_ERROR_INVALID_EVENT /// - ::UR_RESULT_ERROR_INVALID_SIZE @@ -5127,11 +5127,11 @@ urEnqueueUSMPrefetch( /// - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY /// - ::UR_RESULT_ERROR_OUT_OF_RESOURCES UR_APIEXPORT ur_result_t UR_APICALL -urEnqueueUSMMemAdvise( +urEnqueueUSMAdvise( ur_queue_handle_t hQueue, ///< [in] handle of the queue object const void *pMem, ///< [in] pointer to the USM memory object size_t size, ///< [in] size in bytes to be advised - ur_mem_advice_t advice, ///< [in] USM memory advice + ur_usm_advice_t advice, ///< [in] USM memory advice ur_event_handle_t *phEvent ///< [out][optional] return an event object that identifies this particular ///< command instance. ); @@ -7314,25 +7314,25 @@ typedef void(UR_APICALL *ur_pfnEnqueueUSMPrefetchCb_t)( void **ppTracerInstanceUserData); /////////////////////////////////////////////////////////////////////////////// -/// @brief Callback function parameters for urEnqueueUSMMemAdvise +/// @brief Callback function parameters for urEnqueueUSMAdvise /// @details Each entry is a pointer to the parameter passed to the function; /// allowing the callback the ability to modify the parameter's value -typedef struct ur_enqueue_usm_mem_advise_params_t { +typedef struct ur_enqueue_usm_advise_params_t { ur_queue_handle_t *phQueue; const void **ppMem; size_t *psize; - ur_mem_advice_t *padvice; + ur_usm_advice_t *padvice; ur_event_handle_t **pphEvent; -} ur_enqueue_usm_mem_advise_params_t; +} ur_enqueue_usm_advise_params_t; /////////////////////////////////////////////////////////////////////////////// -/// @brief Callback function-pointer for urEnqueueUSMMemAdvise +/// @brief Callback function-pointer for urEnqueueUSMAdvise /// @param[in] params Parameters passed to this instance /// @param[in] result Return value /// @param[in] pTracerUserData Per-Tracer user data /// @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data -typedef void(UR_APICALL *ur_pfnEnqueueUSMMemAdviseCb_t)( - ur_enqueue_usm_mem_advise_params_t *params, +typedef void(UR_APICALL *ur_pfnEnqueueUSMAdviseCb_t)( + ur_enqueue_usm_advise_params_t *params, ur_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData); @@ -7475,7 +7475,7 @@ typedef struct ur_enqueue_callbacks_t { ur_pfnEnqueueUSMFillCb_t pfnUSMFillCb; ur_pfnEnqueueUSMMemcpyCb_t pfnUSMMemcpyCb; ur_pfnEnqueueUSMPrefetchCb_t pfnUSMPrefetchCb; - ur_pfnEnqueueUSMMemAdviseCb_t pfnUSMMemAdviseCb; + ur_pfnEnqueueUSMAdviseCb_t pfnUSMAdviseCb; ur_pfnEnqueueUSMFill2DCb_t pfnUSMFill2DCb; ur_pfnEnqueueUSMMemcpy2DCb_t pfnUSMMemcpy2DCb; ur_pfnEnqueueDeviceGlobalVariableWriteCb_t pfnDeviceGlobalVariableWriteCb; diff --git a/include/ur_ddi.h b/include/ur_ddi.h index a7352c5d93..d661b4ae8f 100644 --- a/include/ur_ddi.h +++ b/include/ur_ddi.h @@ -953,12 +953,12 @@ typedef ur_result_t(UR_APICALL *ur_pfnEnqueueUSMPrefetch_t)( ur_event_handle_t *); /////////////////////////////////////////////////////////////////////////////// -/// @brief Function-pointer for urEnqueueUSMMemAdvise -typedef ur_result_t(UR_APICALL *ur_pfnEnqueueUSMMemAdvise_t)( +/// @brief Function-pointer for urEnqueueUSMAdvise +typedef ur_result_t(UR_APICALL *ur_pfnEnqueueUSMAdvise_t)( ur_queue_handle_t, const void *, size_t, - ur_mem_advice_t, + ur_usm_advice_t, ur_event_handle_t *); /////////////////////////////////////////////////////////////////////////////// @@ -1039,7 +1039,7 @@ typedef struct ur_enqueue_dditable_t { ur_pfnEnqueueUSMFill_t pfnUSMFill; ur_pfnEnqueueUSMMemcpy_t pfnUSMMemcpy; ur_pfnEnqueueUSMPrefetch_t pfnUSMPrefetch; - ur_pfnEnqueueUSMMemAdvise_t pfnUSMMemAdvise; + ur_pfnEnqueueUSMAdvise_t pfnUSMAdvise; ur_pfnEnqueueUSMFill2D_t pfnUSMFill2D; ur_pfnEnqueueUSMMemcpy2D_t pfnUSMMemcpy2D; ur_pfnEnqueueDeviceGlobalVariableWrite_t pfnDeviceGlobalVariableWrite; diff --git a/scripts/core/enqueue.yml b/scripts/core/enqueue.yml index 8be9994880..bf4b661a1c 100644 --- a/scripts/core/enqueue.yml +++ b/scripts/core/enqueue.yml @@ -1115,7 +1115,7 @@ returns: type: function desc: "Enqueue a command to set USM memory advice" class: $xEnqueue -name: USMMemAdvise +name: USMAdvise ordinal: "0" params: - type: $x_queue_handle_t @@ -1127,7 +1127,7 @@ params: - type: size_t name: size desc: "[in] size in bytes to be advised" - - type: $x_mem_advice_t + - type: $x_usm_advice_t name: advice desc: "[in] USM memory advice" - type: $x_event_handle_t* diff --git a/scripts/core/event.yml b/scripts/core/event.yml index 60984a37a3..e0272ccd8c 100644 --- a/scripts/core/event.yml +++ b/scripts/core/event.yml @@ -57,8 +57,8 @@ etors: desc: Event created by $xEnqueueUSMMemcpy - name: USM_PREFETCH desc: Event created by $xEnqueueUSMPrefetch - - name: USM_MEM_ADVISE - desc: Event created by $xEnqueueUSMMemAdvise + - name: USM_ADVISE + desc: Event created by $xEnqueueUSMAdvise - name: USM_FILL_2D desc: Event created by $xEnqueueUSMFill2D - name: USM_MEMCPY_2D diff --git a/scripts/core/registry.yml b/scripts/core/registry.yml index 4c0891fdc4..9884fe25c0 100644 --- a/scripts/core/registry.yml +++ b/scripts/core/registry.yml @@ -109,8 +109,8 @@ etors: - name: ENQUEUE_USM_PREFETCH desc: Enumerator for $xEnqueueUSMPrefetch value: '34' -- name: ENQUEUE_USM_MEM_ADVISE - desc: Enumerator for $xEnqueueUSMMemAdvise +- name: ENQUEUE_USM_ADVISE + desc: Enumerator for $xEnqueueUSMAdvise value: '35' - name: ENQUEUE_USM_FILL2_D desc: Enumerator for $xEnqueueUSMFill2D diff --git a/scripts/core/usm.yml b/scripts/core/usm.yml index 83be2594ad..d7e64022de 100644 --- a/scripts/core/usm.yml +++ b/scripts/core/usm.yml @@ -88,22 +88,22 @@ etors: type: enum desc: "USM memory advice" class: $xUSM -name: $x_mem_advice_t +name: $x_usm_advice_t etors: - name: DEFAULT desc: "The USM memory advice is default" - name: SET_READ_MOSTLY desc: "Hint that memory will be read from frequently and written to rarely" - name: CLEAR_READ_MOSTLY - desc: "Removes the affect of ::$X_MEM_ADVICE_SET_READ_MOSTLY" + desc: "Removes the affect of ::$X_USM_ADVICE_SET_READ_MOSTLY" - name: SET_PREFERRED_LOCATION desc: "Hint that the preferred memory location is the specified device" - name: CLEAR_PREFERRED_LOCATION - desc: "Removes the affect of ::$X_MEM_ADVICE_SET_PREFERRED_LOCATION" + desc: "Removes the affect of ::$X_USM_ADVICE_SET_PREFERRED_LOCATION" - name: SET_NON_ATOMIC_MOSTLY desc: "Hints that memory will mostly be accessed non-atomically" - name: CLEAR_NON_ATOMIC_MOSTLY - desc: "Removes the affect of ::$X_MEM_ADVICE_SET_NON_ATOMIC_MOSTLY" + desc: "Removes the affect of ::$X_USM_ADVICE_SET_NON_ATOMIC_MOSTLY" - name: BIAS_CACHED desc: "Hints that memory should be cached" - name: BIAS_UNCACHED @@ -123,7 +123,7 @@ members: - type: $x_usm_flags_t name: flags desc: "[in] memory allocation flags." - - type: $x_mem_advice_t + - type: $x_usm_advice_t name: hints desc: "[in] Memory advice hints" - type: uint32_t diff --git a/source/drivers/null/ur_nullddi.cpp b/source/drivers/null/ur_nullddi.cpp index e2e3b17d78..1dc0d2f594 100644 --- a/source/drivers/null/ur_nullddi.cpp +++ b/source/drivers/null/ur_nullddi.cpp @@ -2821,12 +2821,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueUSMPrefetch( } /////////////////////////////////////////////////////////////////////////////// -/// @brief Intercept function for urEnqueueUSMMemAdvise -__urdlllocal ur_result_t UR_APICALL urEnqueueUSMMemAdvise( +/// @brief Intercept function for urEnqueueUSMAdvise +__urdlllocal ur_result_t UR_APICALL urEnqueueUSMAdvise( ur_queue_handle_t hQueue, ///< [in] handle of the queue object const void *pMem, ///< [in] pointer to the USM memory object size_t size, ///< [in] size in bytes to be advised - ur_mem_advice_t advice, ///< [in] USM memory advice + ur_usm_advice_t advice, ///< [in] USM memory advice ur_event_handle_t * phEvent ///< [out][optional] return an event object that identifies this particular ///< command instance. @@ -2834,9 +2834,9 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueUSMMemAdvise( ur_result_t result = UR_RESULT_SUCCESS; // if the driver has created a custom function, then call it instead of using the generic path - auto pfnUSMMemAdvise = d_context.urDdiTable.Enqueue.pfnUSMMemAdvise; - if (nullptr != pfnUSMMemAdvise) { - result = pfnUSMMemAdvise(hQueue, pMem, size, advice, phEvent); + auto pfnUSMAdvise = d_context.urDdiTable.Enqueue.pfnUSMAdvise; + if (nullptr != pfnUSMAdvise) { + result = pfnUSMAdvise(hQueue, pMem, size, advice, phEvent); } else { // generic implementation if (nullptr != phEvent) { @@ -3155,7 +3155,7 @@ UR_DLLEXPORT ur_result_t UR_APICALL urGetEnqueueProcAddrTable( pDdiTable->pfnUSMPrefetch = driver::urEnqueueUSMPrefetch; - pDdiTable->pfnUSMMemAdvise = driver::urEnqueueUSMMemAdvise; + pDdiTable->pfnUSMAdvise = driver::urEnqueueUSMAdvise; pDdiTable->pfnUSMFill2D = driver::urEnqueueUSMFill2D; diff --git a/source/loader/layers/tracing/ur_trcddi.cpp b/source/loader/layers/tracing/ur_trcddi.cpp index 0e86488ec5..6e02812880 100644 --- a/source/loader/layers/tracing/ur_trcddi.cpp +++ b/source/loader/layers/tracing/ur_trcddi.cpp @@ -3461,31 +3461,31 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueUSMPrefetch( } /////////////////////////////////////////////////////////////////////////////// -/// @brief Intercept function for urEnqueueUSMMemAdvise -__urdlllocal ur_result_t UR_APICALL urEnqueueUSMMemAdvise( +/// @brief Intercept function for urEnqueueUSMAdvise +__urdlllocal ur_result_t UR_APICALL urEnqueueUSMAdvise( ur_queue_handle_t hQueue, ///< [in] handle of the queue object const void *pMem, ///< [in] pointer to the USM memory object size_t size, ///< [in] size in bytes to be advised - ur_mem_advice_t advice, ///< [in] USM memory advice + ur_usm_advice_t advice, ///< [in] USM memory advice ur_event_handle_t * phEvent ///< [out][optional] return an event object that identifies this particular ///< command instance. ) { - auto pfnUSMMemAdvise = context.urDdiTable.Enqueue.pfnUSMMemAdvise; + auto pfnUSMAdvise = context.urDdiTable.Enqueue.pfnUSMAdvise; - if (nullptr == pfnUSMMemAdvise) { + if (nullptr == pfnUSMAdvise) { return UR_RESULT_ERROR_UNSUPPORTED_FEATURE; } - ur_enqueue_usm_mem_advise_params_t params = {&hQueue, &pMem, &size, &advice, - &phEvent}; - uint64_t instance = context.notify_begin(UR_FUNCTION_ENQUEUE_USM_MEM_ADVISE, - "urEnqueueUSMMemAdvise", ¶ms); + ur_enqueue_usm_advise_params_t params = {&hQueue, &pMem, &size, &advice, + &phEvent}; + uint64_t instance = context.notify_begin(UR_FUNCTION_ENQUEUE_USM_ADVISE, + "urEnqueueUSMAdvise", ¶ms); - ur_result_t result = pfnUSMMemAdvise(hQueue, pMem, size, advice, phEvent); + ur_result_t result = pfnUSMAdvise(hQueue, pMem, size, advice, phEvent); - context.notify_end(UR_FUNCTION_ENQUEUE_USM_MEM_ADVISE, - "urEnqueueUSMMemAdvise", ¶ms, &result, instance); + context.notify_end(UR_FUNCTION_ENQUEUE_USM_ADVISE, "urEnqueueUSMAdvise", + ¶ms, &result, instance); return result; } @@ -3860,8 +3860,8 @@ __urdlllocal ur_result_t UR_APICALL urGetEnqueueProcAddrTable( dditable.pfnUSMPrefetch = pDdiTable->pfnUSMPrefetch; pDdiTable->pfnUSMPrefetch = tracing_layer::urEnqueueUSMPrefetch; - dditable.pfnUSMMemAdvise = pDdiTable->pfnUSMMemAdvise; - pDdiTable->pfnUSMMemAdvise = tracing_layer::urEnqueueUSMMemAdvise; + dditable.pfnUSMAdvise = pDdiTable->pfnUSMAdvise; + pDdiTable->pfnUSMAdvise = tracing_layer::urEnqueueUSMAdvise; dditable.pfnUSMFill2D = pDdiTable->pfnUSMFill2D; pDdiTable->pfnUSMFill2D = tracing_layer::urEnqueueUSMFill2D; diff --git a/source/loader/layers/validation/ur_valddi.cpp b/source/loader/layers/validation/ur_valddi.cpp index cbeddf027e..d50ba4f7df 100644 --- a/source/loader/layers/validation/ur_valddi.cpp +++ b/source/loader/layers/validation/ur_valddi.cpp @@ -4189,19 +4189,19 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueUSMPrefetch( } /////////////////////////////////////////////////////////////////////////////// -/// @brief Intercept function for urEnqueueUSMMemAdvise -__urdlllocal ur_result_t UR_APICALL urEnqueueUSMMemAdvise( +/// @brief Intercept function for urEnqueueUSMAdvise +__urdlllocal ur_result_t UR_APICALL urEnqueueUSMAdvise( ur_queue_handle_t hQueue, ///< [in] handle of the queue object const void *pMem, ///< [in] pointer to the USM memory object size_t size, ///< [in] size in bytes to be advised - ur_mem_advice_t advice, ///< [in] USM memory advice + ur_usm_advice_t advice, ///< [in] USM memory advice ur_event_handle_t * phEvent ///< [out][optional] return an event object that identifies this particular ///< command instance. ) { - auto pfnUSMMemAdvise = context.urDdiTable.Enqueue.pfnUSMMemAdvise; + auto pfnUSMAdvise = context.urDdiTable.Enqueue.pfnUSMAdvise; - if (nullptr == pfnUSMMemAdvise) { + if (nullptr == pfnUSMAdvise) { return UR_RESULT_ERROR_UNSUPPORTED_FEATURE; } @@ -4214,7 +4214,7 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueUSMMemAdvise( return UR_RESULT_ERROR_INVALID_NULL_POINTER; } - if (UR_MEM_ADVICE_BIAS_UNCACHED < advice) { + if (UR_USM_ADVICE_BIAS_UNCACHED < advice) { return UR_RESULT_ERROR_INVALID_ENUMERATION; } @@ -4223,7 +4223,7 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueUSMMemAdvise( } } - ur_result_t result = pfnUSMMemAdvise(hQueue, pMem, size, advice, phEvent); + ur_result_t result = pfnUSMAdvise(hQueue, pMem, size, advice, phEvent); return result; } @@ -4705,8 +4705,8 @@ UR_DLLEXPORT ur_result_t UR_APICALL urGetEnqueueProcAddrTable( dditable.pfnUSMPrefetch = pDdiTable->pfnUSMPrefetch; pDdiTable->pfnUSMPrefetch = validation_layer::urEnqueueUSMPrefetch; - dditable.pfnUSMMemAdvise = pDdiTable->pfnUSMMemAdvise; - pDdiTable->pfnUSMMemAdvise = validation_layer::urEnqueueUSMMemAdvise; + dditable.pfnUSMAdvise = pDdiTable->pfnUSMAdvise; + pDdiTable->pfnUSMAdvise = validation_layer::urEnqueueUSMAdvise; dditable.pfnUSMFill2D = pDdiTable->pfnUSMFill2D; pDdiTable->pfnUSMFill2D = validation_layer::urEnqueueUSMFill2D; diff --git a/source/loader/ur_ldrddi.cpp b/source/loader/ur_ldrddi.cpp index 3cc7a8ad51..840d48bfb9 100644 --- a/source/loader/ur_ldrddi.cpp +++ b/source/loader/ur_ldrddi.cpp @@ -4246,12 +4246,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueUSMPrefetch( } /////////////////////////////////////////////////////////////////////////////// -/// @brief Intercept function for urEnqueueUSMMemAdvise -__urdlllocal ur_result_t UR_APICALL urEnqueueUSMMemAdvise( +/// @brief Intercept function for urEnqueueUSMAdvise +__urdlllocal ur_result_t UR_APICALL urEnqueueUSMAdvise( ur_queue_handle_t hQueue, ///< [in] handle of the queue object const void *pMem, ///< [in] pointer to the USM memory object size_t size, ///< [in] size in bytes to be advised - ur_mem_advice_t advice, ///< [in] USM memory advice + ur_usm_advice_t advice, ///< [in] USM memory advice ur_event_handle_t * phEvent ///< [out][optional] return an event object that identifies this particular ///< command instance. @@ -4260,8 +4260,8 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueUSMMemAdvise( // extract platform's function pointer table auto dditable = reinterpret_cast(hQueue)->dditable; - auto pfnUSMMemAdvise = dditable->ur.Enqueue.pfnUSMMemAdvise; - if (nullptr == pfnUSMMemAdvise) { + auto pfnUSMAdvise = dditable->ur.Enqueue.pfnUSMAdvise; + if (nullptr == pfnUSMAdvise) { return UR_RESULT_ERROR_UNINITIALIZED; } @@ -4269,7 +4269,7 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueUSMMemAdvise( hQueue = reinterpret_cast(hQueue)->handle; // forward to device-platform - result = pfnUSMMemAdvise(hQueue, pMem, size, advice, phEvent); + result = pfnUSMAdvise(hQueue, pMem, size, advice, phEvent); if (UR_RESULT_SUCCESS != result) { return result; @@ -4795,7 +4795,7 @@ UR_DLLEXPORT ur_result_t UR_APICALL urGetEnqueueProcAddrTable( pDdiTable->pfnUSMFill = loader::urEnqueueUSMFill; pDdiTable->pfnUSMMemcpy = loader::urEnqueueUSMMemcpy; pDdiTable->pfnUSMPrefetch = loader::urEnqueueUSMPrefetch; - pDdiTable->pfnUSMMemAdvise = loader::urEnqueueUSMMemAdvise; + pDdiTable->pfnUSMAdvise = loader::urEnqueueUSMAdvise; pDdiTable->pfnUSMFill2D = loader::urEnqueueUSMFill2D; pDdiTable->pfnUSMMemcpy2D = loader::urEnqueueUSMMemcpy2D; pDdiTable->pfnDeviceGlobalVariableWrite = diff --git a/source/loader/ur_libapi.cpp b/source/loader/ur_libapi.cpp index 6715813652..57f9e85835 100644 --- a/source/loader/ur_libapi.cpp +++ b/source/loader/ur_libapi.cpp @@ -4386,7 +4386,7 @@ ur_result_t UR_APICALL urEnqueueUSMPrefetch( /// - ::UR_RESULT_ERROR_INVALID_NULL_POINTER /// + `NULL == pMem` /// - ::UR_RESULT_ERROR_INVALID_ENUMERATION -/// + `::UR_MEM_ADVICE_BIAS_UNCACHED < advice` +/// + `::UR_USM_ADVICE_BIAS_UNCACHED < advice` /// - ::UR_RESULT_ERROR_INVALID_QUEUE /// - ::UR_RESULT_ERROR_INVALID_EVENT /// - ::UR_RESULT_ERROR_INVALID_SIZE @@ -4395,21 +4395,21 @@ ur_result_t UR_APICALL urEnqueueUSMPrefetch( /// - ::UR_RESULT_ERROR_INVALID_MEM_OBJECT /// - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY /// - ::UR_RESULT_ERROR_OUT_OF_RESOURCES -ur_result_t UR_APICALL urEnqueueUSMMemAdvise( +ur_result_t UR_APICALL urEnqueueUSMAdvise( ur_queue_handle_t hQueue, ///< [in] handle of the queue object const void *pMem, ///< [in] pointer to the USM memory object size_t size, ///< [in] size in bytes to be advised - ur_mem_advice_t advice, ///< [in] USM memory advice + ur_usm_advice_t advice, ///< [in] USM memory advice ur_event_handle_t * phEvent ///< [out][optional] return an event object that identifies this particular ///< command instance. ) { - auto pfnUSMMemAdvise = ur_lib::context->urDdiTable.Enqueue.pfnUSMMemAdvise; - if (nullptr == pfnUSMMemAdvise) { + auto pfnUSMAdvise = ur_lib::context->urDdiTable.Enqueue.pfnUSMAdvise; + if (nullptr == pfnUSMAdvise) { return UR_RESULT_ERROR_UNINITIALIZED; } - return pfnUSMMemAdvise(hQueue, pMem, size, advice, phEvent); + return pfnUSMAdvise(hQueue, pMem, size, advice, phEvent); } /////////////////////////////////////////////////////////////////////////////// diff --git a/source/ur_api.cpp b/source/ur_api.cpp index 56ca0f3148..83ad476597 100644 --- a/source/ur_api.cpp +++ b/source/ur_api.cpp @@ -3859,7 +3859,7 @@ ur_result_t UR_APICALL urEnqueueUSMPrefetch( /// - ::UR_RESULT_ERROR_INVALID_NULL_POINTER /// + `NULL == pMem` /// - ::UR_RESULT_ERROR_INVALID_ENUMERATION -/// + `::UR_MEM_ADVICE_BIAS_UNCACHED < advice` +/// + `::UR_USM_ADVICE_BIAS_UNCACHED < advice` /// - ::UR_RESULT_ERROR_INVALID_QUEUE /// - ::UR_RESULT_ERROR_INVALID_EVENT /// - ::UR_RESULT_ERROR_INVALID_SIZE @@ -3868,11 +3868,11 @@ ur_result_t UR_APICALL urEnqueueUSMPrefetch( /// - ::UR_RESULT_ERROR_INVALID_MEM_OBJECT /// - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY /// - ::UR_RESULT_ERROR_OUT_OF_RESOURCES -ur_result_t UR_APICALL urEnqueueUSMMemAdvise( +ur_result_t UR_APICALL urEnqueueUSMAdvise( ur_queue_handle_t hQueue, ///< [in] handle of the queue object const void *pMem, ///< [in] pointer to the USM memory object size_t size, ///< [in] size in bytes to be advised - ur_mem_advice_t advice, ///< [in] USM memory advice + ur_usm_advice_t advice, ///< [in] USM memory advice ur_event_handle_t * phEvent ///< [out][optional] return an event object that identifies this particular ///< command instance. diff --git a/test/conformance/enqueue/CMakeLists.txt b/test/conformance/enqueue/CMakeLists.txt index bf0c9bcf88..7c0eda5ef8 100644 --- a/test/conformance/enqueue/CMakeLists.txt +++ b/test/conformance/enqueue/CMakeLists.txt @@ -21,7 +21,7 @@ add_conformance_test_with_devices_environment(enqueue urEnqueueMemUnmap.cpp urEnqueueUSMFill.cpp urEnqueueUSMFill2D.cpp - urEnqueueUSMMemAdvise.cpp + urEnqueueUSMAdvise.cpp urEnqueueUSMMemcpy.cpp urEnqueueUSMMemcpy2D.cpp urEnqueueUSMPrefetch.cpp diff --git a/test/conformance/enqueue/urEnqueueUSMAdvise.cpp b/test/conformance/enqueue/urEnqueueUSMAdvise.cpp new file mode 100644 index 0000000000..a206c74ae3 --- /dev/null +++ b/test/conformance/enqueue/urEnqueueUSMAdvise.cpp @@ -0,0 +1,60 @@ +// Copyright (C) 2023 Intel Corporation +// SPDX-License-Identifier: MIT + +#include + +using urEnqueueUSMAdviseWithParamTest = + uur::urUSMDeviceAllocTestWithParam; +UUR_TEST_SUITE_P(urEnqueueUSMAdviseWithParamTest, + ::testing::Values(UR_USM_ADVICE_DEFAULT), + uur::deviceTestWithParamPrinter); + +TEST_P(urEnqueueUSMAdviseWithParamTest, Success) { + ur_event_handle_t advise_event = nullptr; + ASSERT_SUCCESS(urEnqueueUSMAdvise(queue, ptr, allocation_size, getParam(), + &advise_event)); + + ASSERT_NE(advise_event, nullptr); + ASSERT_SUCCESS(urQueueFlush(queue)); + ASSERT_SUCCESS(urEventWait(1, &advise_event)); + + ur_event_status_t advise_event_status{}; + ASSERT_SUCCESS(urEventGetInfo( + advise_event, UR_EVENT_INFO_COMMAND_EXECUTION_STATUS, + sizeof(ur_event_status_t), &advise_event_status, nullptr)); + EXPECT_EQ(advise_event_status, UR_EVENT_STATUS_COMPLETE); + ASSERT_SUCCESS(urEventRelease(advise_event)); +} + +using urEnqueueUSMAdviseTest = uur::urUSMDeviceAllocTest; +UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urEnqueueUSMAdviseTest); + +TEST_P(urEnqueueUSMAdviseTest, InvalidNullHandleQueue) { + ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE, + urEnqueueUSMAdvise(nullptr, ptr, allocation_size, + UR_USM_ADVICE_DEFAULT, nullptr)); +} + +TEST_P(urEnqueueUSMAdviseTest, InvalidNullPointerMem) { + ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_POINTER, + urEnqueueUSMAdvise(queue, nullptr, allocation_size, + UR_USM_ADVICE_DEFAULT, nullptr)); +} + +TEST_P(urEnqueueUSMAdviseTest, InvalidEnumeration) { + ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_ENUMERATION, + urEnqueueUSMAdvise(queue, ptr, allocation_size, + UR_USM_ADVICE_FORCE_UINT32, nullptr)); +} + +TEST_P(urEnqueueUSMAdviseTest, InvalidSizeZero) { + ASSERT_EQ_RESULT( + UR_RESULT_ERROR_INVALID_SIZE, + urEnqueueUSMAdvise(queue, ptr, 0, UR_USM_ADVICE_DEFAULT, nullptr)); +} + +TEST_P(urEnqueueUSMAdviseTest, InvalidSizeTooLarge) { + ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_SIZE, + urEnqueueUSMAdvise(queue, ptr, allocation_size * 2, + UR_USM_ADVICE_DEFAULT, nullptr)); +} diff --git a/test/conformance/enqueue/urEnqueueUSMMemAdvise.cpp b/test/conformance/enqueue/urEnqueueUSMMemAdvise.cpp deleted file mode 100644 index efdf2b0106..0000000000 --- a/test/conformance/enqueue/urEnqueueUSMMemAdvise.cpp +++ /dev/null @@ -1,61 +0,0 @@ -// Copyright (C) 2023 Intel Corporation -// SPDX-License-Identifier: MIT - -#include - -using urEnqueueUSMMemAdviseWithParamTest = - uur::urUSMDeviceAllocTestWithParam; -UUR_TEST_SUITE_P(urEnqueueUSMMemAdviseWithParamTest, - ::testing::Values(UR_MEM_ADVICE_DEFAULT), - uur::deviceTestWithParamPrinter); - -TEST_P(urEnqueueUSMMemAdviseWithParamTest, Success) { - ur_event_handle_t advise_event = nullptr; - ASSERT_SUCCESS(urEnqueueUSMMemAdvise(queue, ptr, allocation_size, - getParam(), &advise_event)); - - ASSERT_NE(advise_event, nullptr); - ASSERT_SUCCESS(urQueueFlush(queue)); - ASSERT_SUCCESS(urEventWait(1, &advise_event)); - - ur_event_status_t advise_event_status{}; - ASSERT_SUCCESS(urEventGetInfo( - advise_event, UR_EVENT_INFO_COMMAND_EXECUTION_STATUS, - sizeof(ur_event_status_t), &advise_event_status, nullptr)); - EXPECT_EQ(advise_event_status, UR_EVENT_STATUS_COMPLETE); - ASSERT_SUCCESS(urEventRelease(advise_event)); -} - -using urEnqueueUSMMemAdviseTest = uur::urUSMDeviceAllocTest; -UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urEnqueueUSMMemAdviseTest); - -TEST_P(urEnqueueUSMMemAdviseTest, InvalidNullHandleQueue) { - ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE, - urEnqueueUSMMemAdvise(nullptr, ptr, allocation_size, - UR_MEM_ADVICE_DEFAULT, nullptr)); -} - -TEST_P(urEnqueueUSMMemAdviseTest, InvalidNullPointerMem) { - ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_POINTER, - urEnqueueUSMMemAdvise(queue, nullptr, allocation_size, - UR_MEM_ADVICE_DEFAULT, nullptr)); -} - -TEST_P(urEnqueueUSMMemAdviseTest, InvalidEnumeration) { - ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_ENUMERATION, - urEnqueueUSMMemAdvise(queue, ptr, allocation_size, - UR_MEM_ADVICE_FORCE_UINT32, - nullptr)); -} - -TEST_P(urEnqueueUSMMemAdviseTest, InvalidSizeZero) { - ASSERT_EQ_RESULT( - UR_RESULT_ERROR_INVALID_SIZE, - urEnqueueUSMMemAdvise(queue, ptr, 0, UR_MEM_ADVICE_DEFAULT, nullptr)); -} - -TEST_P(urEnqueueUSMMemAdviseTest, InvalidSizeTooLarge) { - ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_SIZE, - urEnqueueUSMMemAdvise(queue, ptr, allocation_size * 2, - UR_MEM_ADVICE_DEFAULT, nullptr)); -} diff --git a/test/conformance/usm/urUSMSharedAlloc.cpp b/test/conformance/usm/urUSMSharedAlloc.cpp index 120acf5e94..f1962b6076 100644 --- a/test/conformance/usm/urUSMSharedAlloc.cpp +++ b/test/conformance/usm/urUSMSharedAlloc.cpp @@ -49,7 +49,7 @@ TEST_P(urUSMSharedAllocTest, SuccessWithDescriptors) { ur_usm_desc_t usm_desc{UR_STRUCTURE_TYPE_USM_DESC, &usm_host_desc, /* common usm flags */ 0, - /* mem advice flags*/ UR_MEM_ADVICE_DEFAULT}; + /* mem advice flags*/ UR_USM_ADVICE_DEFAULT}; void *ptr = nullptr; size_t allocation_size = sizeof(int); ASSERT_SUCCESS(urUSMSharedAlloc(context, device, &usm_desc, nullptr,