Generated sources

Author: againull

include/ur_api.h

@@ -228,6 +228,7 @@ typedef enum ur_function_t {
     UR_FUNCTION_LOADER_CONFIG_SET_MOCKING_ENABLED = 229,                  ///< Enumerator for ::urLoaderConfigSetMockingEnabled
     UR_FUNCTION_BINDLESS_IMAGES_RELEASE_EXTERNAL_MEMORY_EXP = 230,        ///< Enumerator for ::urBindlessImagesReleaseExternalMemoryExp
     UR_FUNCTION_BINDLESS_IMAGES_MAP_EXTERNAL_LINEAR_MEMORY_EXP = 231,     ///< Enumerator for ::urBindlessImagesMapExternalLinearMemoryExp
+    UR_FUNCTION_PROGRAM_CREATE_WITH_BINARY_EXP = 232,                     ///< Enumerator for ::urProgramCreateWithBinaryExp
     /// @cond
     UR_FUNCTION_FORCE_UINT32 = 0x7fffffff
     /// @endcond
@@ -9401,6 +9402,56 @@ urProgramLinkExp(
     ur_program_handle_t *phProgram         ///< [out] pointer to handle of program object created.
 );
 
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Create a program object from native binaries for the specified
+///        devices.
+///
+/// @details
+///     - The application may call this function from simultaneous threads.
+///     - Following a successful call to this entry point, `phProgram` will
+///       contain binaries of type ::UR_PROGRAM_BINARY_TYPE_COMPILED_OBJECT or
+///       ::UR_PROGRAM_BINARY_TYPE_LIBRARY for the specified devices in
+///       `phDevices`.
+///     - The devices specified by `phDevices` must be associated with the
+///       context.
+///     - The adapter may (but is not required to) perform validation of the
+///       provided modules during this call.
+///
+/// @remarks
+///   _Analogues_
+///     - **clCreateProgramWithBinary**
+///
+/// @returns
+///     - ::UR_RESULT_SUCCESS
+///     - ::UR_RESULT_ERROR_UNINITIALIZED
+///     - ::UR_RESULT_ERROR_DEVICE_LOST
+///     - ::UR_RESULT_ERROR_ADAPTER_SPECIFIC
+///     - ::UR_RESULT_ERROR_INVALID_NULL_HANDLE
+///         + `NULL == hContext`
+///     - ::UR_RESULT_ERROR_INVALID_NULL_POINTER
+///         + `NULL == phDevices`
+///         + `NULL == pLengths`
+///         + `NULL == ppBinaries`
+///         + `NULL == phProgram`
+///         + `NULL != pProperties && pProperties->count > 0 && NULL == pProperties->pMetadatas`
+///     - ::UR_RESULT_ERROR_INVALID_SIZE
+///         + `NULL != pProperties && NULL != pProperties->pMetadatas && pProperties->count == 0`
+///     - ::UR_RESULT_ERROR_INVALID_NATIVE_BINARY
+///         + If any binary in `ppBinaries` isn't a valid binary for the corresponding device in `phDevices.`
+UR_APIEXPORT ur_result_t UR_APICALL
+urProgramCreateWithBinaryExp(
+    ur_context_handle_t hContext,               ///< [in] handle of the context instance
+    uint32_t numDevices,                        ///< [in] number of devices
+    ur_device_handle_t *phDevices,              ///< [in][range(0, numDevices)] a pointer to a list of device handles. The
+                                                ///< binaries are loaded for devices specified in this list.
+    size_t *pLengths,                           ///< [in][range(0, numDevices)] array of sizes of program binaries
+                                                ///< specified by `pBinaries` (in bytes).
+    const uint8_t **ppBinaries,                 ///< [in][range(0, numDevices)] pointer to program binaries to be loaded
+                                                ///< for devices specified by `phDevices`.
+    const ur_program_properties_t *pProperties, ///< [in][optional] pointer to program creation properties.
+    ur_program_handle_t *phProgram              ///< [out] pointer to handle of Program object created.
+);
+
 #if !defined(__GNUC__)
 #pragma endregion
 #endif
@@ -10069,6 +10120,20 @@ typedef struct ur_program_retain_params_t {
     ur_program_handle_t *phProgram;
 } ur_program_retain_params_t;
 
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Function parameters for urProgramCreateWithBinaryExp
+/// @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_program_create_with_binary_exp_params_t {
+    ur_context_handle_t *phContext;
+    uint32_t *pnumDevices;
+    ur_device_handle_t **pphDevices;
+    size_t **ppLengths;
+    const uint8_t ***pppBinaries;
+    const ur_program_properties_t **ppProperties;
+    ur_program_handle_t **pphProgram;
+} ur_program_create_with_binary_exp_params_t;
+
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Function parameters for urProgramRelease
 /// @details Each entry is a pointer to the parameter passed to the function;

include/ur_api_funcs.def

@@ -52,6 +52,7 @@ _UR_API(urProgramCreateWithNativeHandle)
 _UR_API(urProgramBuildExp)
 _UR_API(urProgramCompileExp)
 _UR_API(urProgramLinkExp)
+_UR_API(urProgramCreateWithBinaryExp)
 _UR_API(urKernelCreate)
 _UR_API(urKernelGetInfo)
 _UR_API(urKernelGetGroupInfo)

include/ur_ddi.h

@@ -447,12 +447,24 @@ typedef ur_result_t(UR_APICALL *ur_pfnProgramLinkExp_t)(
     const char *,
     ur_program_handle_t *);
 
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Function-pointer for urProgramCreateWithBinaryExp
+typedef ur_result_t(UR_APICALL *ur_pfnProgramCreateWithBinaryExp_t)(
+    ur_context_handle_t,
+    uint32_t,
+    ur_device_handle_t *,
+    size_t *,
+    const uint8_t **,
+    const ur_program_properties_t *,
+    ur_program_handle_t *);
+
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Table of ProgramExp functions pointers
 typedef struct ur_program_exp_dditable_t {
     ur_pfnProgramBuildExp_t pfnBuildExp;
     ur_pfnProgramCompileExp_t pfnCompileExp;
     ur_pfnProgramLinkExp_t pfnLinkExp;
+    ur_pfnProgramCreateWithBinaryExp_t pfnCreateWithBinaryExp;
 } ur_program_exp_dditable_t;
 
 ///////////////////////////////////////////////////////////////////////////////

include/ur_print.h

@@ -1362,6 +1362,14 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramLinkExpParams(const struct ur_
 ///         - `buff_size < out_size`
 UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramRetainParams(const struct ur_program_retain_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
 
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print ur_program_create_with_binary_exp_params_t struct
+/// @returns
+///     - ::UR_RESULT_SUCCESS
+///     - ::UR_RESULT_ERROR_INVALID_SIZE
+///         - `buff_size < out_size`
+UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramCreateWithBinaryExpParams(const struct ur_program_create_with_binary_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_program_release_params_t struct
 /// @returns

include/ur_print.hpp

@@ -945,6 +945,9 @@ inline std::ostream &operator<<(std::ostream &os, enum ur_function_t value) {
     case UR_FUNCTION_BINDLESS_IMAGES_MAP_EXTERNAL_LINEAR_MEMORY_EXP:
         os << "UR_FUNCTION_BINDLESS_IMAGES_MAP_EXTERNAL_LINEAR_MEMORY_EXP";
         break;
+    case UR_FUNCTION_PROGRAM_CREATE_WITH_BINARY_EXP:
+        os << "UR_FUNCTION_PROGRAM_CREATE_WITH_BINARY_EXP";
+        break;
     default:
         os << "unknown enumerator";
         break;
@@ -11294,6 +11297,72 @@ inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct
     return os;
 }
 
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_program_create_with_binary_exp_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_program_create_with_binary_exp_params_t *params) {
+
+    os << ".hContext = ";
+
+    ur::details::printPtr(os,
+                          *(params->phContext));
+
+    os << ", ";
+    os << ".numDevices = ";
+
+    os << *(params->pnumDevices);
+
+    os << ", ";
+    os << ".phDevices = {";
+    for (size_t i = 0; *(params->pphDevices) != NULL && i < *params->pnumDevices; ++i) {
+        if (i != 0) {
+            os << ", ";
+        }
+
+        ur::details::printPtr(os,
+                              (*(params->pphDevices))[i]);
+    }
+    os << "}";
+
+    os << ", ";
+    os << ".pLengths = {";
+    for (size_t i = 0; *(params->ppLengths) != NULL && i < *params->pnumDevices; ++i) {
+        if (i != 0) {
+            os << ", ";
+        }
+
+        os << (*(params->ppLengths))[i];
+    }
+    os << "}";
+
+    os << ", ";
+    os << ".ppBinaries = {";
+    for (size_t i = 0; *(params->pppBinaries) != NULL && i < *params->pnumDevices; ++i) {
+        if (i != 0) {
+            os << ", ";
+        }
+
+        ur::details::printPtr(os,
+                              (*(params->pppBinaries))[i]);
+    }
+    os << "}";
+
+    os << ", ";
+    os << ".pProperties = ";
+
+    ur::details::printPtr(os,
+                          *(params->ppProperties));
+
+    os << ", ";
+    os << ".phProgram = ";
+
+    ur::details::printPtr(os,
+                          *(params->pphProgram));
+
+    return os;
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print operator for the ur_program_release_params_t type
 /// @returns
@@ -17592,6 +17661,9 @@ inline ur_result_t UR_APICALL printFunctionParams(std::ostream &os, ur_function_
     case UR_FUNCTION_PROGRAM_RETAIN: {
         os << (const struct ur_program_retain_params_t *)params;
     } break;
+    case UR_FUNCTION_PROGRAM_CREATE_WITH_BINARY_EXP: {
+        os << (const struct ur_program_create_with_binary_exp_params_t *)params;
+    } break;
     case UR_FUNCTION_PROGRAM_RELEASE: {
         os << (const struct ur_program_release_params_t *)params;
     } break;

scripts/core/registry.yml

@@ -598,6 +598,9 @@ etors:
 - name: BINDLESS_IMAGES_MAP_EXTERNAL_LINEAR_MEMORY_EXP
   desc: Enumerator for $xBindlessImagesMapExternalLinearMemoryExp
   value: '231'
+- name: PROGRAM_CREATE_WITH_BINARY_EXP
+  desc: Enumerator for $xProgramCreateWithBinaryExp
+  value: '232'
 ---
 type: enum
 desc: Defines structure types

source/adapters/level_zero/ur_interface_loader.cpp

@@ -375,6 +375,8 @@ UR_APIEXPORT ur_result_t UR_APICALL urGetProgramExpProcAddrTable(
   pDdiTable->pfnBuildExp = ur::level_zero::urProgramBuildExp;
   pDdiTable->pfnCompileExp = ur::level_zero::urProgramCompileExp;
   pDdiTable->pfnLinkExp = ur::level_zero::urProgramLinkExp;
+  pDdiTable->pfnCreateWithBinaryExp =
+      ur::level_zero::urProgramCreateWithBinaryExp;
 
   return result;
 }

source/adapters/level_zero/ur_interface_loader.hpp

@@ -681,6 +681,10 @@ ur_result_t urProgramLinkExp(ur_context_handle_t hContext, uint32_t numDevices,
                              const ur_program_handle_t *phPrograms,
                              const char *pOptions,
                              ur_program_handle_t *phProgram);
+ur_result_t urProgramCreateWithBinaryExp(
+    ur_context_handle_t hContext, uint32_t numDevices,
+    ur_device_handle_t *phDevices, size_t *pLengths, const uint8_t **ppBinaries,
+    const ur_program_properties_t *pProperties, ur_program_handle_t *phProgram);
 ur_result_t urUSMImportExp(ur_context_handle_t hContext, void *pMem,
                            size_t size);
 ur_result_t urUSMReleaseExp(ur_context_handle_t hContext, void *pMem);

source/adapters/mock/ur_mockddi.cpp

@@ -9913,6 +9913,68 @@ __urdlllocal ur_result_t UR_APICALL urProgramLinkExp(
     return exceptionToResult(std::current_exception());
 }
 
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Intercept function for urProgramCreateWithBinaryExp
+__urdlllocal ur_result_t UR_APICALL urProgramCreateWithBinaryExp(
+    ur_context_handle_t hContext, ///< [in] handle of the context instance
+    uint32_t numDevices,          ///< [in] number of devices
+    ur_device_handle_t *
+        phDevices, ///< [in][range(0, numDevices)] a pointer to a list of device handles. The
+                   ///< binaries are loaded for devices specified in this list.
+    size_t *
+        pLengths, ///< [in][range(0, numDevices)] array of sizes of program binaries
+                  ///< specified by `pBinaries` (in bytes).
+    const uint8_t **
+        ppBinaries, ///< [in][range(0, numDevices)] pointer to program binaries to be loaded
+                    ///< for devices specified by `phDevices`.
+    const ur_program_properties_t *
+        pProperties, ///< [in][optional] pointer to program creation properties.
+    ur_program_handle_t
+        *phProgram ///< [out] pointer to handle of Program object created.
+    ) try {
+    ur_result_t result = UR_RESULT_SUCCESS;
+
+    ur_program_create_with_binary_exp_params_t params = {
+        &hContext,   &numDevices,  &phDevices, &pLengths,
+        &ppBinaries, &pProperties, &phProgram};
+
+    auto beforeCallback = reinterpret_cast<ur_mock_callback_t>(
+        mock::getCallbacks().get_before_callback(
+            "urProgramCreateWithBinaryExp"));
+    if (beforeCallback) {
+        result = beforeCallback(&params);
+        if (result != UR_RESULT_SUCCESS) {
+            return result;
+        }
+    }
+
+    auto replaceCallback = reinterpret_cast<ur_mock_callback_t>(
+        mock::getCallbacks().get_replace_callback(
+            "urProgramCreateWithBinaryExp"));
+    if (replaceCallback) {
+        result = replaceCallback(&params);
+    } else {
+
+        *phProgram = mock::createDummyHandle<ur_program_handle_t>();
+        result = UR_RESULT_SUCCESS;
+    }
+
+    if (result != UR_RESULT_SUCCESS) {
+        return result;
+    }
+
+    auto afterCallback = reinterpret_cast<ur_mock_callback_t>(
+        mock::getCallbacks().get_after_callback(
+            "urProgramCreateWithBinaryExp"));
+    if (afterCallback) {
+        return afterCallback(&params);
+    }
+
+    return result;
+} catch (...) {
+    return exceptionToResult(std::current_exception());
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Intercept function for urUSMImportExp
 __urdlllocal ur_result_t UR_APICALL urUSMImportExp(
@@ -10948,6 +11010,8 @@ UR_DLLEXPORT ur_result_t UR_APICALL urGetProgramExpProcAddrTable(
 
     pDdiTable->pfnLinkExp = driver::urProgramLinkExp;
 
+    pDdiTable->pfnCreateWithBinaryExp = driver::urProgramCreateWithBinaryExp;
+
     return result;
 } catch (...) {
     return exceptionToResult(std::current_exception());