From abefdaffe867f4ea314d98344b853ea177d75cc1 Mon Sep 17 00:00:00 2001 From: Maosu Zhao Date: Tue, 2 Jul 2024 14:52:34 +0800 Subject: [PATCH 01/36] [DeviceSanitizer] Support detecting memory leaks of USM --- source/loader/layers/sanitizer/asan_interceptor.cpp | 4 ++++ source/loader/layers/sanitizer/asan_report.cpp | 9 +++++++++ source/loader/layers/sanitizer/asan_report.hpp | 2 ++ 3 files changed, 15 insertions(+) diff --git a/source/loader/layers/sanitizer/asan_interceptor.cpp b/source/loader/layers/sanitizer/asan_interceptor.cpp index f1991aaab8..186730cf10 100644 --- a/source/loader/layers/sanitizer/asan_interceptor.cpp +++ b/source/loader/layers/sanitizer/asan_interceptor.cpp @@ -153,6 +153,10 @@ SanitizerInterceptor::SanitizerInterceptor() { SanitizerInterceptor::~SanitizerInterceptor() { DestroyShadowMemoryOnCPU(); DestroyShadowMemoryOnPVC(); + + for (const auto &[_, AI] : m_AllocationMap) { + ReportMemoryLeak(AI); + } } /// The memory chunk allocated from the underlying allocator looks like this: diff --git a/source/loader/layers/sanitizer/asan_report.cpp b/source/loader/layers/sanitizer/asan_report.cpp index 9590e232e4..3cf7009da9 100644 --- a/source/loader/layers/sanitizer/asan_report.cpp +++ b/source/loader/layers/sanitizer/asan_report.cpp @@ -76,6 +76,15 @@ void ReportDoubleFree(uptr Addr, const StackTrace &Stack, AI->AllocStack.print(); } +void ReportMemoryLeak(const std::shared_ptr &AI) { + context.logger.always( + "\n====ERROR: DeviceSanitizer: detected memory leaks of {}", + ToString(AI->Type)); + context.logger.always("Direct leak of {} byte(s) allocated from:", + AI->UserEnd - AI->UserBegin); + AI->AllocStack.print(); +} + void ReportGenericError(const DeviceSanitizerReport &Report) { context.logger.always("\n====ERROR: DeviceSanitizer: {}", ToString(Report.ErrorType)); diff --git a/source/loader/layers/sanitizer/asan_report.hpp b/source/loader/layers/sanitizer/asan_report.hpp index d107b271c0..2999cc4399 100644 --- a/source/loader/layers/sanitizer/asan_report.hpp +++ b/source/loader/layers/sanitizer/asan_report.hpp @@ -31,6 +31,8 @@ void ReportBadContext(uptr Addr, const StackTrace &stack, void ReportDoubleFree(uptr Addr, const StackTrace &Stack, const std::shared_ptr &AllocInfo); +void ReportMemoryLeak(const std::shared_ptr &AI); + void ReportGenericError(const DeviceSanitizerReport &Report); void ReportOutOfBoundsError(const DeviceSanitizerReport &Report, From 8ef2491717a35e7ddd5ca9548e2633b7615f9e15 Mon Sep 17 00:00:00 2001 From: Maosu Zhao Date: Tue, 2 Jul 2024 18:32:26 +0800 Subject: [PATCH 02/36] Update report format and add ref count to context info --- .../layers/sanitizer/asan_interceptor.cpp | 7 ++-- .../layers/sanitizer/asan_interceptor.hpp | 7 +++- .../loader/layers/sanitizer/asan_report.cpp | 4 +-- source/loader/layers/sanitizer/ur_sanddi.cpp | 36 +++++++++++++++++-- 4 files changed, 46 insertions(+), 8 deletions(-) diff --git a/source/loader/layers/sanitizer/asan_interceptor.cpp b/source/loader/layers/sanitizer/asan_interceptor.cpp index 186730cf10..507f347056 100644 --- a/source/loader/layers/sanitizer/asan_interceptor.cpp +++ b/source/loader/layers/sanitizer/asan_interceptor.cpp @@ -154,8 +154,11 @@ SanitizerInterceptor::~SanitizerInterceptor() { DestroyShadowMemoryOnCPU(); DestroyShadowMemoryOnPVC(); - for (const auto &[_, AI] : m_AllocationMap) { - ReportMemoryLeak(AI); + if (!m_AllocationMap.empty()) { + for (const auto &[_, AI] : m_AllocationMap) { + ReportMemoryLeak(AI); + } + exit(1); } } diff --git a/source/loader/layers/sanitizer/asan_interceptor.hpp b/source/loader/layers/sanitizer/asan_interceptor.hpp index 348dff9cc0..a7dc65321c 100644 --- a/source/loader/layers/sanitizer/asan_interceptor.hpp +++ b/source/loader/layers/sanitizer/asan_interceptor.hpp @@ -41,6 +41,7 @@ struct DeviceInfo { uptr ShadowOffset = 0; uptr ShadowOffsetEnd = 0; + // lock this mutex if following fields are accessed ur_mutex Mutex; std::queue> Quarantine; size_t QuarantineSize = 0; @@ -63,6 +64,7 @@ struct DeviceInfo { struct QueueInfo { ur_queue_handle_t Handle; + // lock this mutex if following fields are accessed ur_shared_mutex Mutex; ur_event_handle_t LastEvent; @@ -82,8 +84,10 @@ struct QueueInfo { struct KernelInfo { ur_kernel_handle_t Handle; - ur_shared_mutex Mutex; std::atomic RefCount = 1; + + // lock this mutex if following fields are accessed + ur_shared_mutex Mutex; std::unordered_map> BufferArgs; // Need preserve the order of local arguments @@ -104,6 +108,7 @@ struct KernelInfo { struct ContextInfo { ur_context_handle_t Handle; + std::atomic RefCount = 1; std::vector DeviceList; std::unordered_map AllocInfosMap; diff --git a/source/loader/layers/sanitizer/asan_report.cpp b/source/loader/layers/sanitizer/asan_report.cpp index 3cf7009da9..800e741c8d 100644 --- a/source/loader/layers/sanitizer/asan_report.cpp +++ b/source/loader/layers/sanitizer/asan_report.cpp @@ -80,8 +80,8 @@ void ReportMemoryLeak(const std::shared_ptr &AI) { context.logger.always( "\n====ERROR: DeviceSanitizer: detected memory leaks of {}", ToString(AI->Type)); - context.logger.always("Direct leak of {} byte(s) allocated from:", - AI->UserEnd - AI->UserBegin); + context.logger.always("Direct leak of {} byte(s) at {} allocated from:", + AI->UserEnd - AI->UserBegin, (void *)AI->UserBegin); AI->AllocStack.print(); } diff --git a/source/loader/layers/sanitizer/ur_sanddi.cpp b/source/loader/layers/sanitizer/ur_sanddi.cpp index 713fed4019..30877f5c12 100644 --- a/source/loader/layers/sanitizer/ur_sanddi.cpp +++ b/source/loader/layers/sanitizer/ur_sanddi.cpp @@ -358,6 +358,29 @@ __urdlllocal ur_result_t UR_APICALL urContextCreateWithNativeHandle( return result; } +/////////////////////////////////////////////////////////////////////////////// +/// @brief Intercept function for urContextRetain +__urdlllocal ur_result_t UR_APICALL +urContextRetain( + ur_context_handle_t hContext ///< [in] handle of the context to get a reference of. +) { + auto pfnRetain = context.urDdiTable.Context.pfnRetain; + + if (nullptr == pfnRetain) { + return UR_RESULT_ERROR_UNSUPPORTED_FEATURE; + } + + context.logger.debug("==== urContextRetain"); + + UR_CALL(pfnRetain(hContext)); + + if (auto ContextInfo = context.interceptor->getContextInfo(hContext)) { + ContextInfo->RefCount++; + } + + return UR_RESULT_SUCCESS; +} + /////////////////////////////////////////////////////////////////////////////// /// @brief Intercept function for urContextRelease __urdlllocal ur_result_t UR_APICALL urContextRelease( @@ -371,10 +394,16 @@ __urdlllocal ur_result_t UR_APICALL urContextRelease( context.logger.debug("==== urContextRelease"); - UR_CALL(context.interceptor->eraseContext(hContext)); - ur_result_t result = pfnRelease(hContext); + UR_CALL(pfnRelease(hContext)); - return result; + if (auto ContextInfo = context.interceptor->getContextInfo(hContext)) { + if (--ContextInfo->RefCount != 0) { + return UR_RESULT_SUCCESS; + } + UR_CALL(context.interceptor->eraseContext(hContext)); + } + + return UR_RESULT_SUCCESS; } /////////////////////////////////////////////////////////////////////////////// @@ -1293,6 +1322,7 @@ __urdlllocal ur_result_t UR_APICALL urGetContextProcAddrTable( ur_result_t result = UR_RESULT_SUCCESS; pDdiTable->pfnCreate = ur_sanitizer_layer::urContextCreate; + pDdiTable->pfnRetain = ur_sanitizer_layer::urContextRetain; pDdiTable->pfnRelease = ur_sanitizer_layer::urContextRelease; pDdiTable->pfnCreateWithNativeHandle = From 600ace1f915b2f2679bd479945a2ecf3a7280c0e Mon Sep 17 00:00:00 2001 From: Maosu Zhao Date: Wed, 3 Jul 2024 15:25:11 +0800 Subject: [PATCH 03/36] Fix format --- source/loader/layers/sanitizer/ur_sanddi.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/source/loader/layers/sanitizer/ur_sanddi.cpp b/source/loader/layers/sanitizer/ur_sanddi.cpp index 30877f5c12..bb58492c15 100644 --- a/source/loader/layers/sanitizer/ur_sanddi.cpp +++ b/source/loader/layers/sanitizer/ur_sanddi.cpp @@ -360,9 +360,9 @@ __urdlllocal ur_result_t UR_APICALL urContextCreateWithNativeHandle( /////////////////////////////////////////////////////////////////////////////// /// @brief Intercept function for urContextRetain -__urdlllocal ur_result_t UR_APICALL -urContextRetain( - ur_context_handle_t hContext ///< [in] handle of the context to get a reference of. +__urdlllocal ur_result_t UR_APICALL urContextRetain( + ur_context_handle_t + hContext ///< [in] handle of the context to get a reference of. ) { auto pfnRetain = context.urDdiTable.Context.pfnRetain; From 60b48c0c027a54cf54c12d9818421bebc4d0d320 Mon Sep 17 00:00:00 2001 From: Maosu Zhao Date: Thu, 4 Jul 2024 11:27:25 +0800 Subject: [PATCH 04/36] Update as per comments --- .../layers/sanitizer/asan_interceptor.cpp | 4 ++- source/loader/layers/sanitizer/ur_sanddi.cpp | 26 +++++++++---------- 2 files changed, 15 insertions(+), 15 deletions(-) diff --git a/source/loader/layers/sanitizer/asan_interceptor.cpp b/source/loader/layers/sanitizer/asan_interceptor.cpp index 507f347056..5aaae397a9 100644 --- a/source/loader/layers/sanitizer/asan_interceptor.cpp +++ b/source/loader/layers/sanitizer/asan_interceptor.cpp @@ -156,7 +156,9 @@ SanitizerInterceptor::~SanitizerInterceptor() { if (!m_AllocationMap.empty()) { for (const auto &[_, AI] : m_AllocationMap) { - ReportMemoryLeak(AI); + if (!AI->IsReleased) { + ReportMemoryLeak(AI); + } } exit(1); } diff --git a/source/loader/layers/sanitizer/ur_sanddi.cpp b/source/loader/layers/sanitizer/ur_sanddi.cpp index bb58492c15..59ab75377e 100644 --- a/source/loader/layers/sanitizer/ur_sanddi.cpp +++ b/source/loader/layers/sanitizer/ur_sanddi.cpp @@ -374,9 +374,9 @@ __urdlllocal ur_result_t UR_APICALL urContextRetain( UR_CALL(pfnRetain(hContext)); - if (auto ContextInfo = context.interceptor->getContextInfo(hContext)) { - ContextInfo->RefCount++; - } + auto ContextInfo = context.interceptor->getContextInfo(hContext); + UR_ASSERT(ContextInfo != nullptr, UR_RESULT_ERROR_INVALID_VALUE); + ContextInfo->RefCount++; return UR_RESULT_SUCCESS; } @@ -396,10 +396,9 @@ __urdlllocal ur_result_t UR_APICALL urContextRelease( UR_CALL(pfnRelease(hContext)); - if (auto ContextInfo = context.interceptor->getContextInfo(hContext)) { - if (--ContextInfo->RefCount != 0) { - return UR_RESULT_SUCCESS; - } + auto ContextInfo = context.interceptor->getContextInfo(hContext); + UR_ASSERT(ContextInfo != nullptr, UR_RESULT_ERROR_INVALID_VALUE); + if (--ContextInfo->RefCount == 0) { UR_CALL(context.interceptor->eraseContext(hContext)); } @@ -1167,9 +1166,9 @@ __urdlllocal ur_result_t UR_APICALL urKernelRetain( UR_CALL(pfnRetain(hKernel)); - if (auto KernelInfo = context.interceptor->getKernelInfo(hKernel)) { - KernelInfo->RefCount++; - } + auto KernelInfo = context.interceptor->getKernelInfo(hKernel); + UR_ASSERT(KernelInfo != nullptr, UR_RESULT_ERROR_INVALID_VALUE); + KernelInfo->RefCount++; return UR_RESULT_SUCCESS; } @@ -1188,10 +1187,9 @@ __urdlllocal ur_result_t urKernelRelease( context.logger.debug("==== urKernelRelease"); UR_CALL(pfnRelease(hKernel)); - if (auto KernelInfo = context.interceptor->getKernelInfo(hKernel)) { - if (--KernelInfo->RefCount != 0) { - return UR_RESULT_SUCCESS; - } + auto KernelInfo = context.interceptor->getKernelInfo(hKernel); + UR_ASSERT(KernelInfo != nullptr, UR_RESULT_ERROR_INVALID_VALUE); + if (--KernelInfo->RefCount == 0) { UR_CALL(context.interceptor->eraseKernel(hKernel)); } From 3c84edbf037a2d2cadd0ae9d81249e00b8e3ec93 Mon Sep 17 00:00:00 2001 From: Maosu Zhao Date: Thu, 4 Jul 2024 11:47:37 +0800 Subject: [PATCH 05/36] Minor fix --- source/loader/layers/sanitizer/asan_interceptor.cpp | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/source/loader/layers/sanitizer/asan_interceptor.cpp b/source/loader/layers/sanitizer/asan_interceptor.cpp index 5aaae397a9..ccdca7ddb2 100644 --- a/source/loader/layers/sanitizer/asan_interceptor.cpp +++ b/source/loader/layers/sanitizer/asan_interceptor.cpp @@ -154,12 +154,14 @@ SanitizerInterceptor::~SanitizerInterceptor() { DestroyShadowMemoryOnCPU(); DestroyShadowMemoryOnPVC(); - if (!m_AllocationMap.empty()) { - for (const auto &[_, AI] : m_AllocationMap) { - if (!AI->IsReleased) { - ReportMemoryLeak(AI); - } + bool HasLeak = false; + for (const auto &[_, AI] : m_AllocationMap) { + if (!AI->IsReleased) { + HasLeak = true; + ReportMemoryLeak(AI); } + } + if (HasLeak) { exit(1); } } From 2f9bcf541160dea56a1062cd4b7c63e32e1f1bf7 Mon Sep 17 00:00:00 2001 From: Maosu Zhao Date: Mon, 8 Jul 2024 09:43:39 +0800 Subject: [PATCH 06/36] Lock the mutex --- source/loader/layers/sanitizer/asan_interceptor.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/source/loader/layers/sanitizer/asan_interceptor.cpp b/source/loader/layers/sanitizer/asan_interceptor.cpp index ccdca7ddb2..92ba063c1c 100644 --- a/source/loader/layers/sanitizer/asan_interceptor.cpp +++ b/source/loader/layers/sanitizer/asan_interceptor.cpp @@ -154,6 +154,7 @@ SanitizerInterceptor::~SanitizerInterceptor() { DestroyShadowMemoryOnCPU(); DestroyShadowMemoryOnPVC(); + std::shared_lock Guard(m_AllocationMapMutex); bool HasLeak = false; for (const auto &[_, AI] : m_AllocationMap) { if (!AI->IsReleased) { From 2e0dbb5ff0f25751c5a793bb9e52ca6b2f43e9d6 Mon Sep 17 00:00:00 2001 From: Maosu Zhao Date: Thu, 18 Jul 2024 18:07:10 +0800 Subject: [PATCH 07/36] Report leak when context is released --- .../layers/sanitizer/asan_interceptor.cpp | 46 +++++++++++++++---- .../layers/sanitizer/asan_interceptor.hpp | 11 +++-- .../loader/layers/sanitizer/asan_report.cpp | 4 +- 3 files changed, 45 insertions(+), 16 deletions(-) diff --git a/source/loader/layers/sanitizer/asan_interceptor.cpp b/source/loader/layers/sanitizer/asan_interceptor.cpp index 167056f708..2ef672b843 100644 --- a/source/loader/layers/sanitizer/asan_interceptor.cpp +++ b/source/loader/layers/sanitizer/asan_interceptor.cpp @@ -146,6 +146,8 @@ ur_result_t enqueueMemSetShadow(ur_context_handle_t Context, } // namespace +bool SanitizerInterceptor::AbnormalExit = false; + SanitizerInterceptor::SanitizerInterceptor(logger::Logger &logger) : logger(logger) { if (Options(logger).MaxQuarantineSizeMB) { @@ -159,15 +161,7 @@ SanitizerInterceptor::~SanitizerInterceptor() { DestroyShadowMemoryOnCPU(); DestroyShadowMemoryOnPVC(); - std::shared_lock Guard(m_AllocationMapMutex); - bool HasLeak = false; - for (const auto &[_, AI] : m_AllocationMap) { - if (!AI->IsReleased) { - HasLeak = true; - ReportMemoryLeak(AI); - } - } - if (HasLeak) { + if (AbnormalExit) { exit(1); } } @@ -887,6 +881,40 @@ SanitizerInterceptor::findAllocInfoByAddress(uptr Address) { return It; } +std::vector +SanitizerInterceptor::findAllocInfoByContext(ur_context_handle_t Context) { + std::shared_lock Guard(m_AllocationMapMutex); + std::vector AllocInfos; + for (auto It = m_AllocationMap.begin(); It != m_AllocationMap.end(); It++) { + const auto &[_, AI] = *It; + if (AI->Context == Context) { + AllocInfos.emplace_back(It); + } + } + return AllocInfos; +} + +ContextInfo::~ContextInfo() { + [[maybe_unused]] auto Result = + getContext()->urDdiTable.Context.pfnRelease(Handle); + assert(Result == UR_RESULT_SUCCESS); + + bool HasLeak = false; + std::vector AllocInfos = + getContext()->interceptor->findAllocInfoByContext(Handle); + for (const auto &It : AllocInfos) { + const auto &[_, AI] = *It; + if (AI->IsReleased) { + ReportMemoryLeak(AI); + HasLeak = true; + } + } + + if (HasLeak) { + SanitizerInterceptor::AbnormalExit = true; + } +} + ur_result_t USMLaunchInfo::initialize() { UR_CALL(getContext()->urDdiTable.Context.pfnRetain(Context)); UR_CALL(getContext()->urDdiTable.Device.pfnRetain(Device)); diff --git a/source/loader/layers/sanitizer/asan_interceptor.hpp b/source/loader/layers/sanitizer/asan_interceptor.hpp index bc961d2c6b..dfa00b7d9a 100644 --- a/source/loader/layers/sanitizer/asan_interceptor.hpp +++ b/source/loader/layers/sanitizer/asan_interceptor.hpp @@ -119,11 +119,7 @@ struct ContextInfo { assert(Result == UR_RESULT_SUCCESS); } - ~ContextInfo() { - [[maybe_unused]] auto Result = - getContext()->urDdiTable.Context.pfnRelease(Handle); - assert(Result == UR_RESULT_SUCCESS); - } + ~ContextInfo(); void insertAllocInfo(const std::vector &Devices, std::shared_ptr &AI) { @@ -169,6 +165,8 @@ struct DeviceGlobalInfo { class SanitizerInterceptor { public: + static bool AbnormalExit; + explicit SanitizerInterceptor(logger::Logger &logger); ~SanitizerInterceptor(); @@ -208,6 +206,9 @@ class SanitizerInterceptor { std::optional findAllocInfoByAddress(uptr Address); + std::vector + findAllocInfoByContext(ur_context_handle_t Context); + std::shared_ptr getContextInfo(ur_context_handle_t Context) { std::shared_lock Guard(m_ContextMapMutex); assert(m_ContextMap.find(Context) != m_ContextMap.end()); diff --git a/source/loader/layers/sanitizer/asan_report.cpp b/source/loader/layers/sanitizer/asan_report.cpp index f59b840bbd..4acc664096 100644 --- a/source/loader/layers/sanitizer/asan_report.cpp +++ b/source/loader/layers/sanitizer/asan_report.cpp @@ -77,10 +77,10 @@ void ReportDoubleFree(uptr Addr, const StackTrace &Stack, } void ReportMemoryLeak(const std::shared_ptr &AI) { - context.logger.always( + getContext()->logger.always( "\n====ERROR: DeviceSanitizer: detected memory leaks of {}", ToString(AI->Type)); - context.logger.always("Direct leak of {} byte(s) at {} allocated from:", + getContext()->logger.always("Direct leak of {} byte(s) at {} allocated from:", AI->UserEnd - AI->UserBegin, (void *)AI->UserBegin); AI->AllocStack.print(); } From eaf7e4792abab4e873a2b16b805efd451a93529a Mon Sep 17 00:00:00 2001 From: Maosu Zhao Date: Fri, 19 Jul 2024 13:26:19 +0800 Subject: [PATCH 08/36] remove abnormal exit --- .../loader/layers/sanitizer/asan_interceptor.cpp | 14 +------------- .../loader/layers/sanitizer/asan_interceptor.hpp | 2 -- 2 files changed, 1 insertion(+), 15 deletions(-) diff --git a/source/loader/layers/sanitizer/asan_interceptor.cpp b/source/loader/layers/sanitizer/asan_interceptor.cpp index 2ef672b843..30a242a055 100644 --- a/source/loader/layers/sanitizer/asan_interceptor.cpp +++ b/source/loader/layers/sanitizer/asan_interceptor.cpp @@ -146,8 +146,6 @@ ur_result_t enqueueMemSetShadow(ur_context_handle_t Context, } // namespace -bool SanitizerInterceptor::AbnormalExit = false; - SanitizerInterceptor::SanitizerInterceptor(logger::Logger &logger) : logger(logger) { if (Options(logger).MaxQuarantineSizeMB) { @@ -160,10 +158,6 @@ SanitizerInterceptor::SanitizerInterceptor(logger::Logger &logger) SanitizerInterceptor::~SanitizerInterceptor() { DestroyShadowMemoryOnCPU(); DestroyShadowMemoryOnPVC(); - - if (AbnormalExit) { - exit(1); - } } /// The memory chunk allocated from the underlying allocator looks like this: @@ -899,20 +893,14 @@ ContextInfo::~ContextInfo() { getContext()->urDdiTable.Context.pfnRelease(Handle); assert(Result == UR_RESULT_SUCCESS); - bool HasLeak = false; std::vector AllocInfos = getContext()->interceptor->findAllocInfoByContext(Handle); for (const auto &It : AllocInfos) { const auto &[_, AI] = *It; - if (AI->IsReleased) { + if (!AI->IsReleased) { ReportMemoryLeak(AI); - HasLeak = true; } } - - if (HasLeak) { - SanitizerInterceptor::AbnormalExit = true; - } } ur_result_t USMLaunchInfo::initialize() { diff --git a/source/loader/layers/sanitizer/asan_interceptor.hpp b/source/loader/layers/sanitizer/asan_interceptor.hpp index dfa00b7d9a..cc6b46f72f 100644 --- a/source/loader/layers/sanitizer/asan_interceptor.hpp +++ b/source/loader/layers/sanitizer/asan_interceptor.hpp @@ -165,8 +165,6 @@ struct DeviceGlobalInfo { class SanitizerInterceptor { public: - static bool AbnormalExit; - explicit SanitizerInterceptor(logger::Logger &logger); ~SanitizerInterceptor(); From 6877561fefaf1ab2cda1ae7f3668ff1bc12265cc Mon Sep 17 00:00:00 2001 From: "Zhao, Yang2" Date: Wed, 31 Jul 2024 22:49:57 -0700 Subject: [PATCH 09/36] nullpointer detection --- source/loader/layers/sanitizer/asan_interceptor.cpp | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/source/loader/layers/sanitizer/asan_interceptor.cpp b/source/loader/layers/sanitizer/asan_interceptor.cpp index 0deb021a3f..71210d8c21 100644 --- a/source/loader/layers/sanitizer/asan_interceptor.cpp +++ b/source/loader/layers/sanitizer/asan_interceptor.cpp @@ -425,6 +425,18 @@ ur_result_t DeviceInfo::allocShadowMemory(ur_context_handle_t Context) { } getContext()->logger.info("ShadowMemory(Global): {} - {}", (void *)ShadowOffset, (void *)ShadowOffsetEnd); + + // Set shadow memory for null pointer + ManagedQueue Queue(Context, Handle); + + auto DI = getContext()->interceptor->getDeviceInfo(Handle); + auto URes = + enqueueMemSetShadow(Context, DI, Queue, 0, 1, kNullPointerRedzoneMagic); + if (URes != UR_RESULT_SUCCESS) { + getContext()->logger.error("enqueueMemSetShadow(NullPointerRZ): {}", + URes); + return URes; + } return UR_RESULT_SUCCESS; } From da60a148941583b0b587212df59f106f718c2be6 Mon Sep 17 00:00:00 2001 From: "Wu, Yingcong" Date: Tue, 6 Aug 2024 10:25:25 +0800 Subject: [PATCH 10/36] exclude shadow from coredump --- source/loader/layers/sanitizer/asan_shadow_setup.cpp | 1 + source/loader/layers/sanitizer/common.hpp | 1 + source/loader/layers/sanitizer/linux/sanitizer_utils.cpp | 6 ++++++ 3 files changed, 8 insertions(+) diff --git a/source/loader/layers/sanitizer/asan_shadow_setup.cpp b/source/loader/layers/sanitizer/asan_shadow_setup.cpp index 37ecbce281..3c037657ac 100644 --- a/source/loader/layers/sanitizer/asan_shadow_setup.cpp +++ b/source/loader/layers/sanitizer/asan_shadow_setup.cpp @@ -29,6 +29,7 @@ ur_result_t SetupShadowMemory(uptr &ShadowBegin, uptr &ShadowEnd) { if (SHADOW_BEGIN == 0) { return UR_RESULT_ERROR_OUT_OF_HOST_MEMORY; } + DontCoredumpRange(SHADOW_BEGIN, SHADOW_SIZE); SHADOW_END = SHADOW_BEGIN + SHADOW_SIZE; IsShadowMemInited = true; return UR_RESULT_SUCCESS; diff --git a/source/loader/layers/sanitizer/common.hpp b/source/loader/layers/sanitizer/common.hpp index 9e8fa93902..cde9c2efed 100644 --- a/source/loader/layers/sanitizer/common.hpp +++ b/source/loader/layers/sanitizer/common.hpp @@ -142,6 +142,7 @@ bool IsInASanContext(); uptr MmapNoReserve(uptr Addr, uptr Size); bool Munmap(uptr Addr, uptr Size); +bool DontCoredumpRange(uptr Addr, uptr Size); void *GetMemFunctionPointer(const char *); diff --git a/source/loader/layers/sanitizer/linux/sanitizer_utils.cpp b/source/loader/layers/sanitizer/linux/sanitizer_utils.cpp index 64704180ad..d0bc038174 100644 --- a/source/loader/layers/sanitizer/linux/sanitizer_utils.cpp +++ b/source/loader/layers/sanitizer/linux/sanitizer_utils.cpp @@ -37,6 +37,12 @@ uptr MmapNoReserve(uptr Addr, uptr Size) { bool Munmap(uptr Addr, uptr Size) { return munmap((void *)Addr, Size) == 0; } +bool DontCoredumpRange(uptr Addr, uptr Size) { + Size = RoundUpTo(Size, EXEC_PAGESIZE); + Addr = RoundDownTo(Addr, EXEC_PAGESIZE); + return madvise((void *)Addr, Size, MADV_DONTDUMP) == 0; +} + void *GetMemFunctionPointer(const char *FuncName) { void *handle = dlopen(LIBC_SO, RTLD_LAZY | RTLD_NOLOAD); if (!handle) { From 465bab88bcf28a80e4fd890b982bf9a60cfe294c Mon Sep 17 00:00:00 2001 From: "Wu, Yingcong" Date: Wed, 28 Aug 2024 22:46:21 -0700 Subject: [PATCH 11/36] add fix --- source/loader/layers/sanitizer/asan_buffer.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/source/loader/layers/sanitizer/asan_buffer.cpp b/source/loader/layers/sanitizer/asan_buffer.cpp index 382d6e3ada..58cde4bea1 100644 --- a/source/loader/layers/sanitizer/asan_buffer.cpp +++ b/source/loader/layers/sanitizer/asan_buffer.cpp @@ -183,8 +183,8 @@ size_t MemBuffer::getAlignment() { // usually choose a very large size (more than 1k). Then sanitizer will // allocate extra unnessary memory. Not sure if this will impact // performance. - size_t MsbIdx = 63 - __builtin_clz(Size); - size_t Alignment = (1 << (MsbIdx + 1)); + size_t MsbIdx = 63 - __builtin_clzg(Size); + size_t Alignment = (1ULL << (MsbIdx + 1)); if (Alignment > 128) { Alignment = 128; } From 4f64257ddcdc55a9b60500648342150aeb9181df Mon Sep 17 00:00:00 2001 From: "Wu, Yingcong" Date: Wed, 28 Aug 2024 23:14:20 -0700 Subject: [PATCH 12/36] use clzl --- source/loader/layers/sanitizer/asan_buffer.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/loader/layers/sanitizer/asan_buffer.cpp b/source/loader/layers/sanitizer/asan_buffer.cpp index 58cde4bea1..896fee986e 100644 --- a/source/loader/layers/sanitizer/asan_buffer.cpp +++ b/source/loader/layers/sanitizer/asan_buffer.cpp @@ -183,7 +183,7 @@ size_t MemBuffer::getAlignment() { // usually choose a very large size (more than 1k). Then sanitizer will // allocate extra unnessary memory. Not sure if this will impact // performance. - size_t MsbIdx = 63 - __builtin_clzg(Size); + size_t MsbIdx = 63 - __builtin_clzl(Size); size_t Alignment = (1ULL << (MsbIdx + 1)); if (Alignment > 128) { Alignment = 128; From ff79addbccd9d0ee59a15e1084bf6935efd91813 Mon Sep 17 00:00:00 2001 From: "Neil R. Spruit" Date: Wed, 28 Aug 2024 10:24:52 -0700 Subject: [PATCH 13/36] [L0] Add 3-channel image support - add support for UR_IMAGE_CHANNEL_ORDER_RGB and UR_IMAGE_CHANNEL_ORDER_RGX Signed-off-by: Neil R. Spruit --- source/adapters/level_zero/image.cpp | 45 +++++++++++++++++++++++++++- 1 file changed, 44 insertions(+), 1 deletion(-) diff --git a/source/adapters/level_zero/image.cpp b/source/adapters/level_zero/image.cpp index f68b2d93be..c6e40566e5 100644 --- a/source/adapters/level_zero/image.cpp +++ b/source/adapters/level_zero/image.cpp @@ -37,16 +37,19 @@ ur_result_t ze2urImageFormat(const ze_image_desc_t *ZeImageDesc, switch (ZeImageFormat.layout) { case ZE_IMAGE_FORMAT_LAYOUT_8: case ZE_IMAGE_FORMAT_LAYOUT_8_8: + case ZE_IMAGE_FORMAT_LAYOUT_8_8_8: case ZE_IMAGE_FORMAT_LAYOUT_8_8_8_8: ZeImageFormatTypeSize = 8; break; case ZE_IMAGE_FORMAT_LAYOUT_16: case ZE_IMAGE_FORMAT_LAYOUT_16_16: + case ZE_IMAGE_FORMAT_LAYOUT_16_16_16: case ZE_IMAGE_FORMAT_LAYOUT_16_16_16_16: ZeImageFormatTypeSize = 16; break; case ZE_IMAGE_FORMAT_LAYOUT_32: case ZE_IMAGE_FORMAT_LAYOUT_32_32: + case ZE_IMAGE_FORMAT_LAYOUT_32_32_32: case ZE_IMAGE_FORMAT_LAYOUT_32_32_32_32: ZeImageFormatTypeSize = 32; break; @@ -98,7 +101,29 @@ ur_result_t ze2urImageFormat(const ze_image_desc_t *ZeImageDesc, default: logger::error( "ze2urImageFormat: unexpected image format channel y: y = {}\n", - ZeImageFormat.x); + ZeImageFormat.y); + return UR_RESULT_ERROR_INVALID_VALUE; + } + break; + case ZE_IMAGE_FORMAT_LAYOUT_8_8_8: + case ZE_IMAGE_FORMAT_LAYOUT_16_16_16: + case ZE_IMAGE_FORMAT_LAYOUT_32_32_32: + if (ZeImageFormat.x != ZE_IMAGE_FORMAT_SWIZZLE_R && + ZeImageFormat.y != ZE_IMAGE_FORMAT_SWIZZLE_G) { + logger::error("ze2urImageFormat: unexpected image format channel"); + return UR_RESULT_ERROR_INVALID_VALUE; + } + switch (ZeImageFormat.z) { + case ZE_IMAGE_FORMAT_SWIZZLE_B: + ChannelOrder = UR_IMAGE_CHANNEL_ORDER_RGB; + break; + case ZE_IMAGE_FORMAT_SWIZZLE_X: + ChannelOrder = UR_IMAGE_CHANNEL_ORDER_RGX; + break; + default: + logger::error( + "ze2urImageFormat: unexpected image format channel z: z = {}\n", + ZeImageFormat.z); return UR_RESULT_ERROR_INVALID_VALUE; } break; @@ -303,6 +328,24 @@ ur_result_t ur2zeImageDesc(const ur_image_format_t *ImageFormat, } break; } + case UR_IMAGE_CHANNEL_ORDER_RGB: + case UR_IMAGE_CHANNEL_ORDER_RGX: { + switch (ZeImageFormatTypeSize) { + case 8: + ZeImageFormatLayout = ZE_IMAGE_FORMAT_LAYOUT_8_8_8; + break; + case 16: + ZeImageFormatLayout = ZE_IMAGE_FORMAT_LAYOUT_16_16_16; + break; + case 32: + ZeImageFormatLayout = ZE_IMAGE_FORMAT_LAYOUT_32_32_32; + break; + default: + logger::error("ur2zeImageDesc: unexpected data type size"); + return UR_RESULT_ERROR_INVALID_VALUE; + } + break; + } default: logger::error("format channel order = {}", ImageFormat->channelOrder); die("ur2zeImageDesc: unsupported image channel order\n"); From 71cdf2538608b867c3cf3c1e852c80c94da8be01 Mon Sep 17 00:00:00 2001 From: "Neil R. Spruit" Date: Wed, 28 Aug 2024 11:09:15 -0700 Subject: [PATCH 14/36] [L0] Return error if not exactly RGB or RGX Signed-off-by: Neil R. Spruit --- source/adapters/level_zero/image.cpp | 31 ++++++++++++++-------------- 1 file changed, 16 insertions(+), 15 deletions(-) diff --git a/source/adapters/level_zero/image.cpp b/source/adapters/level_zero/image.cpp index c6e40566e5..527cb62caa 100644 --- a/source/adapters/level_zero/image.cpp +++ b/source/adapters/level_zero/image.cpp @@ -108,24 +108,25 @@ ur_result_t ze2urImageFormat(const ze_image_desc_t *ZeImageDesc, case ZE_IMAGE_FORMAT_LAYOUT_8_8_8: case ZE_IMAGE_FORMAT_LAYOUT_16_16_16: case ZE_IMAGE_FORMAT_LAYOUT_32_32_32: - if (ZeImageFormat.x != ZE_IMAGE_FORMAT_SWIZZLE_R && - ZeImageFormat.y != ZE_IMAGE_FORMAT_SWIZZLE_G) { + if (ZeImageFormat.x == ZE_IMAGE_FORMAT_SWIZZLE_R && + ZeImageFormat.y == ZE_IMAGE_FORMAT_SWIZZLE_G) { + switch (ZeImageFormat.z) { + case ZE_IMAGE_FORMAT_SWIZZLE_B: + ChannelOrder = UR_IMAGE_CHANNEL_ORDER_RGB; + break; + case ZE_IMAGE_FORMAT_SWIZZLE_X: + ChannelOrder = UR_IMAGE_CHANNEL_ORDER_RGX; + break; + default: + logger::error( + "ze2urImageFormat: unexpected image format channel z: z = {}\n", + ZeImageFormat.z); + return UR_RESULT_ERROR_INVALID_VALUE; + } + } else { logger::error("ze2urImageFormat: unexpected image format channel"); return UR_RESULT_ERROR_INVALID_VALUE; } - switch (ZeImageFormat.z) { - case ZE_IMAGE_FORMAT_SWIZZLE_B: - ChannelOrder = UR_IMAGE_CHANNEL_ORDER_RGB; - break; - case ZE_IMAGE_FORMAT_SWIZZLE_X: - ChannelOrder = UR_IMAGE_CHANNEL_ORDER_RGX; - break; - default: - logger::error( - "ze2urImageFormat: unexpected image format channel z: z = {}\n", - ZeImageFormat.z); - return UR_RESULT_ERROR_INVALID_VALUE; - } break; case ZE_IMAGE_FORMAT_LAYOUT_8_8_8_8: case ZE_IMAGE_FORMAT_LAYOUT_16_16_16_16: From 6d2ed69e5114370dc495738297aaebfca47fae4d Mon Sep 17 00:00:00 2001 From: Maosu Zhao Date: Fri, 30 Aug 2024 17:12:23 +0800 Subject: [PATCH 15/36] [DeviceSanitizer] Don't report warning if write __AsanDebug failed --- source/loader/layers/sanitizer/asan_interceptor.cpp | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/source/loader/layers/sanitizer/asan_interceptor.cpp b/source/loader/layers/sanitizer/asan_interceptor.cpp index ec1d5e8fad..a8cd139dd5 100644 --- a/source/loader/layers/sanitizer/asan_interceptor.cpp +++ b/source/loader/layers/sanitizer/asan_interceptor.cpp @@ -748,14 +748,14 @@ ur_result_t SanitizerInterceptor::prepareLaunch( } // Write global variable to program - auto EnqueueWriteGlobal = [Queue, Program](const char *Name, - const void *Value, - size_t Size) { + auto EnqueueWriteGlobal = [Queue, Program]( + const char *Name, const void *Value, + size_t Size, bool ReportWarning = true) { auto Result = getContext()->urDdiTable.Enqueue.pfnDeviceGlobalVariableWrite( Queue, Program, Name, false, Size, 0, Value, 0, nullptr, nullptr); - if (Result != UR_RESULT_SUCCESS) { + if (ReportWarning && Result != UR_RESULT_SUCCESS) { getContext()->logger.warning( "Failed to write device global \"{}\": {}", Name, Result); return false; @@ -768,7 +768,7 @@ ur_result_t SanitizerInterceptor::prepareLaunch( // Because EnqueueWriteGlobal is a async write, so // we need to extend its lifetime static uint64_t Debug = Options(logger).Debug ? 1 : 0; - EnqueueWriteGlobal(kSPIR_AsanDebug, &Debug, sizeof(Debug)); + EnqueueWriteGlobal(kSPIR_AsanDebug, &Debug, sizeof(Debug), false); // Write shadow memory offset for global memory EnqueueWriteGlobal(kSPIR_AsanShadowMemoryGlobalStart, From 59a9bdbf116eaa105703ee187af2535d1fbb5d7a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C5=81ukasz=20=C5=9Alusarczyk?= Date: Fri, 13 Sep 2024 22:39:38 +0200 Subject: [PATCH 16/36] fixed issue #1990, L0 leaks checker counts successful create/destroys only --- source/adapters/level_zero/adapter.cpp | 12 ++++++------ source/adapters/level_zero/common.cpp | 9 ++++++--- 2 files changed, 12 insertions(+), 9 deletions(-) diff --git a/source/adapters/level_zero/adapter.cpp b/source/adapters/level_zero/adapter.cpp index eaabb70a29..4171f9c7ee 100644 --- a/source/adapters/level_zero/adapter.cpp +++ b/source/adapters/level_zero/adapter.cpp @@ -188,12 +188,11 @@ void globalAdapterOnDemandCleanup() { } ur_result_t adapterStateTeardown() { - bool LeakFound = false; - // Print the balance of various create/destroy native calls. // The idea is to verify if the number of create(+) and destroy(-) calls are // matched. if (ZeCallCount && (UrL0LeaksDebug) != 0) { + bool LeakFound = false; // clang-format off // // The format of this table is such that each row accounts for a @@ -276,11 +275,12 @@ ur_result_t adapterStateTeardown() { ZeCallCount->clear(); delete ZeCallCount; ZeCallCount = nullptr; + if (LeakFound) + return UR_RESULT_ERROR_INVALID_MEM_OBJECT; } - if (LeakFound) - return UR_RESULT_ERROR_INVALID_MEM_OBJECT; - // Due to multiple DLLMain definitions with SYCL, register to cleanup the - // Global Adapter after refcnt is 0 + + // Due to multiple DLLMain definitions with SYCL, register to cleanup the + // Global Adapter after refcnt is 0 #if defined(_WIN32) umfTearDown(); std::atexit(globalAdapterOnDemandCleanup); diff --git a/source/adapters/level_zero/common.cpp b/source/adapters/level_zero/common.cpp index 7031bb5f03..f5d8b20014 100644 --- a/source/adapters/level_zero/common.cpp +++ b/source/adapters/level_zero/common.cpp @@ -145,11 +145,14 @@ ze_result_t ZeCall::doCall(ze_result_t ZeResult, const char *ZeName, const char *ZeArgs, bool TraceError) { logger::debug("ZE ---> {}{}", ZeName, ZeArgs); - if (UrL0LeaksDebug) { - ++(*ZeCallCount)[ZeName]; + if (ZeResult == ZE_RESULT_SUCCESS) { + if (UrL0LeaksDebug) { + ++(*ZeCallCount)[ZeName]; + } + return ZE_RESULT_SUCCESS; } - if (ZeResult && TraceError) { + if (TraceError) { const char *ErrorString = "Unknown"; zeParseError(ZeResult, ErrorString); logger::error("Error ({}) in {}", ErrorString, ZeName); From 731296622e91effdf32addddb34ec2d1303118f5 Mon Sep 17 00:00:00 2001 From: Ross Brunton Date: Tue, 17 Sep 2024 15:25:05 +0100 Subject: [PATCH 17/36] Deterministic mode and improvements for match.py Some improvements for match.py: * Added a {{NONDETERMINISTIC}} tag, which indicates that the match file results need not be in order. * When printing output, line numbers and the "interesting line" are provided. * Fix incorrect index being used when no lines matching a "match" line are found. In addition, all the conformance test match files are marked as "{{NONDETERMINISTIC}}", as they may be ran in different orders depending on compile flags. --- cmake/match.py | 147 +++++++++++++----- .../adapter/adapter_adapter_native_cpu.match | 1 + .../context/context_adapter_level_zero.match | 1 + .../context_adapter_level_zero_v2.match | 1 + .../context/context_adapter_native_cpu.match | 1 + .../device/device_adapter_cuda.match | 1 + .../device/device_adapter_hip.match | 1 + .../device/device_adapter_level_zero.match | 1 + .../device/device_adapter_level_zero_v2.match | 1 + .../device/device_adapter_native_cpu.match | 1 + .../device/device_adapter_opencl.match | 1 + .../enqueue/enqueue_adapter_cuda.match | 1 + .../enqueue/enqueue_adapter_hip.match | 1 + .../enqueue/enqueue_adapter_level_zero.match | 1 + .../enqueue_adapter_level_zero_v2.match | 1 + .../enqueue/enqueue_adapter_native_cpu.match | 1 + .../enqueue/enqueue_adapter_opencl.match | 1 + .../event/event_adapter_cuda.match | 1 + .../conformance/event/event_adapter_hip.match | 1 + .../event/event_adapter_level_zero.match | 1 + .../event/event_adapter_level_zero_v2.match | 1 + .../event/event_adapter_native_cpu.match | 1 + ...command_buffer_adapter_level_zero_v2.match | 1 + ...xp_command_buffer_adapter_native_cpu.match | 1 + ...enqueue_native_adapter_level_zero_v2.match | 1 + ...launch_properties_adapter_native_cpu.match | 1 + .../integration_adapter_level_zero.match | 1 + .../integration_adapter_level_zero_v2.match | 1 + .../integration_adapter_native_cpu.match | 1 + .../integration_adapter_opencl.match | 1 + .../kernel/kernel_adapter_cuda.match | 1 + .../kernel/kernel_adapter_hip.match | 1 + .../kernel/kernel_adapter_level_zero.match | 1 + .../kernel/kernel_adapter_level_zero_v2.match | 1 + .../kernel/kernel_adapter_native_cpu.match | 1 + .../kernel/kernel_adapter_opencl.match | 1 + .../memory/memory_adapter_cuda.match | 1 + .../memory/memory_adapter_hip.match | 1 + .../memory/memory_adapter_level_zero.match | 1 + .../memory/memory_adapter_level_zero_v2.match | 1 + .../memory/memory_adapter_native_cpu.match | 1 + .../memory/memory_adapter_opencl.match | 1 + .../platform/platform_adapter_cuda.match | 1 + .../platform/platform_adapter_hip.match | 1 + .../platform_adapter_native_cpu.match | 1 + .../program/program_adapter_cuda.match | 1 + .../program/program_adapter_hip.match | 1 + .../program/program_adapter_level_zero.match | 1 + .../program_adapter_level_zero_v2.match | 1 + .../program/program_adapter_native_cpu.match | 1 + .../program/program_adapter_opencl.match | 1 + .../queue/queue_adapter_native_cpu.match | 1 + .../sampler/sampler_adapter_level_zero.match | 1 + .../sampler_adapter_level_zero_v2.match | 1 + test/conformance/usm/usm_adapter_cuda.match | 1 + test/conformance/usm/usm_adapter_hip.match | 1 + .../usm/usm_adapter_level_zero.match | 1 + .../usm/usm_adapter_level_zero_v2.match | 1 + .../usm/usm_adapter_native_cpu.match | 1 + test/conformance/usm/usm_adapter_opencl.match | 1 + .../virtual_memory_adapter_level_zero.match | 1 + ...virtual_memory_adapter_level_zero_v2.match | 2 +- 62 files changed, 169 insertions(+), 40 deletions(-) diff --git a/cmake/match.py b/cmake/match.py index 5b96d3008f..8075ab201c 100755 --- a/cmake/match.py +++ b/cmake/match.py @@ -1,4 +1,4 @@ -#!/usr/bin/env python +#!/usr/bin/env python3 # Copyright (C) 2023 Intel Corporation # Part of the Unified-Runtime Project, under the Apache License v2.0 with LLVM Exceptions. @@ -12,6 +12,8 @@ # List of available special tags: # {{OPT}} - makes content in the same line as the tag optional # {{IGNORE}} - ignores all content until the next successfully matched line or the end of the input +# {{NONDETERMINISTIC}} - order of match rules isn't important - each (non OPT) input line is paired with a match line +# in any order # Special tags are mutually exclusive and are expected to be located at the start of a line. # @@ -20,15 +22,25 @@ import re from enum import Enum +## @brief print a sequence of lines +def print_lines(lines, hint = None): + counter = 1 + for l in lines: + hint_char = " " + if hint == counter - 1: + hint_char = ">" + print("{}{:4d}| {}".format(hint_char, counter, l.strip())) + counter += 1 + ## @brief print the whole content of input and match files -def print_content(input_lines, match_lines, ignored_lines): - print("--- Input Lines " + "-" * 64) - print("".join(input_lines).strip()) - print("--- Match Lines " + "-" * 64) - print("".join(match_lines).strip()) - print("--- Ignored Lines " + "-" * 62) - print("".join(ignored_lines).strip()) +def print_content(input_lines, match_lines, ignored_lines, hint_input = None, hint_match = None): + print("------ Input Lines " + "-" * 61) + print_lines(input_lines, hint_input) + print("------ Match Lines " + "-" * 61) + print_lines(match_lines, hint_match) + print("------ Ignored Lines " + "-" * 59) + print_lines(ignored_lines) print("-" * 80) @@ -39,6 +51,24 @@ def print_incorrect_match(match_line, present, expected): print("expected: " + expected) +## @brief print missing match line +def print_input_not_found(input_line, input): + print("Input line " + str(input_line) + " has no match line") + print("is: " + input) + + +## @brief print missing input line +def print_match_not_found(match_line, input): + print("Match line " + str(match_line) + " has no input line") + print("is: " + input) + + +## @brief print general syntax error +def print_error(text, match_line): + print("Line " + str(match_line) + " encountered an error") + print(text) + + ## @brief pattern matching script status values class Status(Enum): INPUT_END = 1 @@ -63,6 +93,7 @@ def check_status(input_lines, match_lines): class Tag(Enum): OPT = "{{OPT}}" # makes the line optional IGNORE = "{{IGNORE}}" # ignores all input until next match or end of input file + NONDETERMINISTIC = "{{NONDETERMINISTIC}}" # switches on "deterministic mode" COMMENT = "#" # comment - line ignored @@ -88,32 +119,53 @@ def main(): ) ignored_lines = [] + matched_lines = set() input_idx = 0 match_idx = 0 tags_in_effect = [] + deterministic_mode = False while True: # check file status status = check_status(input_lines[input_idx:], match_lines[match_idx:]) - if (status == Status.INPUT_AND_MATCH_END) or (status == Status.MATCH_END and Tag.IGNORE in tags_in_effect): - # all lines matched or the last line in match file is an ignore tag - sys.exit(0) - elif status == Status.MATCH_END: - print_incorrect_match(match_idx + 1, input_lines[input_idx].strip(), ""); - print_content(input_lines, match_lines, ignored_lines) - sys.exit(1) - elif status == Status.INPUT_END: - # If we get to the end of the input, but still have pending matches, - # then that's a failure unless all pending matches are optional - - # otherwise we're done - while match_idx < len(match_lines): - if not (match_lines[match_idx].startswith(Tag.OPT.value) or - match_lines[match_idx].startswith(Tag.IGNORE.value)): - print_incorrect_match(match_idx + 1, "", match_lines[match_idx]); - print_content(input_lines, match_lines, ignored_lines) + if deterministic_mode: + if status == Status.INPUT_END: + # Convert the list of seen matches to the list of unseen matches + remaining_matches = set(range(len(match_lines))) - matched_lines + for m in remaining_matches: + line = match_lines[m] + if line.startswith(Tag.OPT.value) or line.startswith(Tag.NONDETERMINISTIC.value): + continue + print_match_not_found(m + 1, match_lines[m]) + print_content(input_lines, match_lines, ignored_lines, hint_match=m) sys.exit(1) - match_idx += 1 - sys.exit(0) + + sys.exit(0) + elif status == Status.MATCH_END: + print_input_not_found(input_idx + 1, input_lines[input_idx]) + print_content(input_lines, match_lines, ignored_lines, hint_input=input_idx) + sys.exit(1) + else: + if (status == Status.INPUT_AND_MATCH_END) or (status == Status.MATCH_END and Tag.IGNORE in tags_in_effect): + # all lines matched or the last line in match file is an ignore tag + sys.exit(0) + elif status == Status.MATCH_END: + print_incorrect_match(input_idx + 1, input_lines[input_idx].strip(), "") + print_content(input_lines, match_lines, ignored_lines, hint_input=input_idx) + sys.exit(1) + elif status == Status.INPUT_END: + # If we get to the end of the input, but still have pending matches, + # then that's a failure unless all pending matches are optional - + # otherwise we're done + while match_idx < len(match_lines): + if not (match_lines[match_idx].startswith(Tag.OPT.value) or + match_lines[match_idx].startswith(Tag.IGNORE.value) or + match_lines[match_idx].startswith(Tag.NONDETERMINISTIC.value)): + print_incorrect_match(match_idx + 1, "", match_lines[match_idx]) + print_content(input_lines, match_lines, ignored_lines, hint_match=match_idx) + sys.exit(1) + match_idx += 1 + sys.exit(0) input_line = input_lines[input_idx].strip() if input_idx < len(input_lines) else "" match_line = match_lines[match_idx] @@ -122,7 +174,15 @@ def main(): if match_line.startswith(Tag.OPT.value): tags_in_effect.append(Tag.OPT) match_line = match_line[len(Tag.OPT.value):] + elif match_line.startswith(Tag.NONDETERMINISTIC.value) and not deterministic_mode: + deterministic_mode = True + match_idx = 0 + input_idx = 0 + continue elif match_line.startswith(Tag.IGNORE.value): + if deterministic_mode: + print_error(r"Can't use \{{IGNORE\}} in deterministic mode") + sys.exit(2) tags_in_effect.append(Tag.IGNORE) match_idx += 1 continue # line with ignore tag should be skipped @@ -137,20 +197,29 @@ def main(): pattern += part # match or process tags - if re.fullmatch(pattern, input_line): - input_idx += 1 - match_idx += 1 - tags_in_effect = [] - elif Tag.OPT in tags_in_effect: - match_idx += 1 - tags_in_effect.remove(Tag.OPT) - elif Tag.IGNORE in tags_in_effect: - ignored_lines.append(input_line + os.linesep) - input_idx += 1 + if deterministic_mode: + if re.fullmatch(pattern, input_line) and match_idx not in matched_lines: + input_idx += 1 + matched_lines.add(match_idx) + match_idx = 0 + tags_in_effect = [] + else: + match_idx += 1 else: - print_incorrect_match(match_idx + 1, input_line, match_line.strip()) - print_content(input_lines, match_lines, ignored_lines) - sys.exit(1) + if re.fullmatch(pattern, input_line): + input_idx += 1 + match_idx += 1 + tags_in_effect = [] + elif Tag.OPT in tags_in_effect: + match_idx += 1 + tags_in_effect.remove(Tag.OPT) + elif Tag.IGNORE in tags_in_effect: + ignored_lines.append(input_line + os.linesep) + input_idx += 1 + else: + print_incorrect_match(match_idx + 1, input_line, match_line.strip()) + print_content(input_lines, match_lines, ignored_lines, hint_match=match_idx, hint_input=input_idx) + sys.exit(1) if __name__ == "__main__": diff --git a/test/conformance/adapter/adapter_adapter_native_cpu.match b/test/conformance/adapter/adapter_adapter_native_cpu.match index 5bc60575e2..1335caf904 100644 --- a/test/conformance/adapter/adapter_adapter_native_cpu.match +++ b/test/conformance/adapter/adapter_adapter_native_cpu.match @@ -1,3 +1,4 @@ +{{NONDETERMINISTIC}} urAdapterGetLastErrorTest.Success urAdapterGetLastErrorTest.InvalidHandle urAdapterGetLastErrorTest.InvalidMessagePtr diff --git a/test/conformance/context/context_adapter_level_zero.match b/test/conformance/context/context_adapter_level_zero.match index f25df872a3..151368c3c0 100644 --- a/test/conformance/context/context_adapter_level_zero.match +++ b/test/conformance/context/context_adapter_level_zero.match @@ -1,2 +1,3 @@ +{{NONDETERMINISTIC}} urContextCreateWithNativeHandleTest.SuccessWithUnOwnedNativeHandle/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_ urContextSetExtendedDeleterTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_ diff --git a/test/conformance/context/context_adapter_level_zero_v2.match b/test/conformance/context/context_adapter_level_zero_v2.match index 3dea8da6e5..e77c47c0cf 100644 --- a/test/conformance/context/context_adapter_level_zero_v2.match +++ b/test/conformance/context/context_adapter_level_zero_v2.match @@ -1,3 +1,4 @@ +{{NONDETERMINISTIC}} urContextCreateWithNativeHandleTest.InvalidNullHandleAdapter/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}__ urContextCreateWithNativeHandleTest.InvalidNullPointerContext/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}__ urContextSetExtendedDeleterTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}__ diff --git a/test/conformance/context/context_adapter_native_cpu.match b/test/conformance/context/context_adapter_native_cpu.match index 2ad35ad411..32b479f09e 100644 --- a/test/conformance/context/context_adapter_native_cpu.match +++ b/test/conformance/context/context_adapter_native_cpu.match @@ -1,3 +1,4 @@ +{{NONDETERMINISTIC}} urContextCreateWithNativeHandleTest.InvalidNullHandleAdapter/SYCL_NATIVE_CPU___SYCL_Native_CPU__{{.*}} urContextCreateWithNativeHandleTest.InvalidNullPointerContext/SYCL_NATIVE_CPU___SYCL_Native_CPU__{{.*}} urContextSetExtendedDeleterTest.Success/SYCL_NATIVE_CPU___SYCL_Native_CPU__{{.*}} diff --git a/test/conformance/device/device_adapter_cuda.match b/test/conformance/device/device_adapter_cuda.match index 9989fbd774..ce2e071f36 100644 --- a/test/conformance/device/device_adapter_cuda.match +++ b/test/conformance/device/device_adapter_cuda.match @@ -1,2 +1,3 @@ +{{NONDETERMINISTIC}} urDeviceCreateWithNativeHandleTest.SuccessWithUnOwnedNativeHandle {{OPT}}urDeviceGetGlobalTimestampTest.SuccessSynchronizedTime diff --git a/test/conformance/device/device_adapter_hip.match b/test/conformance/device/device_adapter_hip.match index 9989fbd774..ce2e071f36 100644 --- a/test/conformance/device/device_adapter_hip.match +++ b/test/conformance/device/device_adapter_hip.match @@ -1,2 +1,3 @@ +{{NONDETERMINISTIC}} urDeviceCreateWithNativeHandleTest.SuccessWithUnOwnedNativeHandle {{OPT}}urDeviceGetGlobalTimestampTest.SuccessSynchronizedTime diff --git a/test/conformance/device/device_adapter_level_zero.match b/test/conformance/device/device_adapter_level_zero.match index 162c342477..1200505671 100644 --- a/test/conformance/device/device_adapter_level_zero.match +++ b/test/conformance/device/device_adapter_level_zero.match @@ -1,3 +1,4 @@ +{{NONDETERMINISTIC}} urDeviceCreateWithNativeHandleTest.SuccessWithUnOwnedNativeHandle {{OPT}}urDeviceGetGlobalTimestampTest.SuccessSynchronizedTime {{OPT}}urDeviceGetInfoTest.Success/UR_DEVICE_INFO_GLOBAL_MEM_FREE diff --git a/test/conformance/device/device_adapter_level_zero_v2.match b/test/conformance/device/device_adapter_level_zero_v2.match index 162c342477..1200505671 100644 --- a/test/conformance/device/device_adapter_level_zero_v2.match +++ b/test/conformance/device/device_adapter_level_zero_v2.match @@ -1,3 +1,4 @@ +{{NONDETERMINISTIC}} urDeviceCreateWithNativeHandleTest.SuccessWithUnOwnedNativeHandle {{OPT}}urDeviceGetGlobalTimestampTest.SuccessSynchronizedTime {{OPT}}urDeviceGetInfoTest.Success/UR_DEVICE_INFO_GLOBAL_MEM_FREE diff --git a/test/conformance/device/device_adapter_native_cpu.match b/test/conformance/device/device_adapter_native_cpu.match index a590340f58..b2f88f3bc8 100644 --- a/test/conformance/device/device_adapter_native_cpu.match +++ b/test/conformance/device/device_adapter_native_cpu.match @@ -1,3 +1,4 @@ +{{NONDETERMINISTIC}} urDeviceCreateWithNativeHandleTest.InvalidNullHandlePlatform urDeviceCreateWithNativeHandleTest.InvalidNullPointerDevice {{OPT}}urDeviceGetGlobalTimestampTest.SuccessSynchronizedTime diff --git a/test/conformance/device/device_adapter_opencl.match b/test/conformance/device/device_adapter_opencl.match index 39854cbcd3..c5f7397c54 100644 --- a/test/conformance/device/device_adapter_opencl.match +++ b/test/conformance/device/device_adapter_opencl.match @@ -1 +1,2 @@ +{{NONDETERMINISTIC}} urDeviceCreateWithNativeHandleTest.SuccessWithUnOwnedNativeHandle diff --git a/test/conformance/enqueue/enqueue_adapter_cuda.match b/test/conformance/enqueue/enqueue_adapter_cuda.match index 381612066d..40de7158d0 100644 --- a/test/conformance/enqueue/enqueue_adapter_cuda.match +++ b/test/conformance/enqueue/enqueue_adapter_cuda.match @@ -1,3 +1,4 @@ +{{NONDETERMINISTIC}} urEnqueueKernelLaunchTest.InvalidKernelArgs/NVIDIA_CUDA_BACKEND___{{.*}}_ urEnqueueKernelLaunchKernelWgSizeTest.NonMatchingLocalSize/NVIDIA_CUDA_BACKEND___{{.*}}_ urEnqueueKernelLaunchKernelSubGroupTest.Success/NVIDIA_CUDA_BACKEND___{{.*}}_ diff --git a/test/conformance/enqueue/enqueue_adapter_hip.match b/test/conformance/enqueue/enqueue_adapter_hip.match index f602837b14..b841a25cf4 100644 --- a/test/conformance/enqueue/enqueue_adapter_hip.match +++ b/test/conformance/enqueue/enqueue_adapter_hip.match @@ -1,3 +1,4 @@ +{{NONDETERMINISTIC}} # HIP can't check kernel arguments urEnqueueKernelLaunchTest.InvalidKernelArgs/AMD_HIP_BACKEND___{{.*}}_ urEnqueueKernelLaunchKernelWgSizeTest.NonMatchingLocalSize/AMD_HIP_BACKEND___{{.*}}_ diff --git a/test/conformance/enqueue/enqueue_adapter_level_zero.match b/test/conformance/enqueue/enqueue_adapter_level_zero.match index 42215b39a3..1c85a579b9 100644 --- a/test/conformance/enqueue/enqueue_adapter_level_zero.match +++ b/test/conformance/enqueue/enqueue_adapter_level_zero.match @@ -1,3 +1,4 @@ +{{NONDETERMINISTIC}} {{OPT}}urEnqueueEventsWaitTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_ {{OPT}}urEnqueueKernelLaunchTest.InvalidKernelArgs/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_ {{OPT}}urEnqueueKernelLaunchKernelWgSizeTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_ diff --git a/test/conformance/enqueue/enqueue_adapter_level_zero_v2.match b/test/conformance/enqueue/enqueue_adapter_level_zero_v2.match index e48c5175b4..df2be32782 100644 --- a/test/conformance/enqueue/enqueue_adapter_level_zero_v2.match +++ b/test/conformance/enqueue/enqueue_adapter_level_zero_v2.match @@ -1,3 +1,4 @@ +{{NONDETERMINISTIC}} urEnqueueDeviceGetGlobalVariableReadTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_ urEnqueueKernelLaunchTest.InvalidKernelArgs/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_ urEnqueueKernelLaunchKernelWgSizeTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_ diff --git a/test/conformance/enqueue/enqueue_adapter_native_cpu.match b/test/conformance/enqueue/enqueue_adapter_native_cpu.match index fc3cf2d975..a7d6797f94 100644 --- a/test/conformance/enqueue/enqueue_adapter_native_cpu.match +++ b/test/conformance/enqueue/enqueue_adapter_native_cpu.match @@ -1,3 +1,4 @@ +{{NONDETERMINISTIC}} {{OPT}}urEnqueueDeviceGetGlobalVariableReadTest.Success/SYCL_NATIVE_CPU___SYCL_Native_CPU__{{.*}} {{OPT}}urEnqueueDeviceGetGlobalVariableReadTest.InvalidNullHandleQueue/SYCL_NATIVE_CPU___SYCL_Native_CPU__{{.*}} {{OPT}}urEnqueueDeviceGetGlobalVariableReadTest.InvalidNullHandleProgram/SYCL_NATIVE_CPU___SYCL_Native_CPU__{{.*}} diff --git a/test/conformance/enqueue/enqueue_adapter_opencl.match b/test/conformance/enqueue/enqueue_adapter_opencl.match index 7bb41276d4..d67d35d9b0 100644 --- a/test/conformance/enqueue/enqueue_adapter_opencl.match +++ b/test/conformance/enqueue/enqueue_adapter_opencl.match @@ -1,3 +1,4 @@ +{{NONDETERMINISTIC}} {{OPT}}urEnqueueDeviceGetGlobalVariableReadTest.Success/Intel_R__OpenCL___{{.*}}_ urEnqueueKernelLaunchKernelWgSizeTest.Success/Intel_R__OpenCL___{{.*}}_ urEnqueueKernelLaunchKernelSubGroupTest.Success/Intel_R__OpenCL___{{.*}}_ diff --git a/test/conformance/event/event_adapter_cuda.match b/test/conformance/event/event_adapter_cuda.match index 3cffb24c5f..d9e14551da 100644 --- a/test/conformance/event/event_adapter_cuda.match +++ b/test/conformance/event/event_adapter_cuda.match @@ -1,3 +1,4 @@ +{{NONDETERMINISTIC}} urEventGetProfilingInfoTest.Success/NVIDIA_CUDA_BACKEND___{{.*}}___UR_PROFILING_INFO_COMMAND_COMPLETE urEventGetProfilingInfoWithTimingComparisonTest.Success/NVIDIA_CUDA_BACKEND___{{.*}}_ urEventSetCallbackTest.Success/NVIDIA_CUDA_BACKEND___{{.*}}_ diff --git a/test/conformance/event/event_adapter_hip.match b/test/conformance/event/event_adapter_hip.match index b25428a187..6bc909c5fd 100644 --- a/test/conformance/event/event_adapter_hip.match +++ b/test/conformance/event/event_adapter_hip.match @@ -1,3 +1,4 @@ +{{NONDETERMINISTIC}} urEventGetProfilingInfoTest.Success/AMD_HIP_BACKEND___{{.*}}___UR_PROFILING_INFO_COMMAND_COMPLETE urEventGetProfilingInfoWithTimingComparisonTest.Success/AMD_HIP_BACKEND___{{.*}}_ urEventSetCallbackTest.Success/AMD_HIP_BACKEND___{{.*}}_ diff --git a/test/conformance/event/event_adapter_level_zero.match b/test/conformance/event/event_adapter_level_zero.match index 32ffbeaf1e..cae719ef16 100644 --- a/test/conformance/event/event_adapter_level_zero.match +++ b/test/conformance/event/event_adapter_level_zero.match @@ -1,3 +1,4 @@ +{{NONDETERMINISTIC}} {{OPT}}urEventGetInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_EVENT_INFO_COMMAND_TYPE {{OPT}}urEventGetProfilingInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROFILING_INFO_COMMAND_QUEUED {{OPT}}urEventGetProfilingInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROFILING_INFO_COMMAND_SUBMIT diff --git a/test/conformance/event/event_adapter_level_zero_v2.match b/test/conformance/event/event_adapter_level_zero_v2.match index e3f93c54c3..8d297d117d 100644 --- a/test/conformance/event/event_adapter_level_zero_v2.match +++ b/test/conformance/event/event_adapter_level_zero_v2.match @@ -1,3 +1,4 @@ +{{NONDETERMINISTIC}} urEventGetInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_EVENT_INFO_COMMAND_QUEUE urEventGetInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_EVENT_INFO_CONTEXT urEventGetInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_EVENT_INFO_COMMAND_TYPE diff --git a/test/conformance/event/event_adapter_native_cpu.match b/test/conformance/event/event_adapter_native_cpu.match index fe9e18f4ac..17066b6d52 100644 --- a/test/conformance/event/event_adapter_native_cpu.match +++ b/test/conformance/event/event_adapter_native_cpu.match @@ -1,3 +1,4 @@ +{{NONDETERMINISTIC}} urEventGetInfoTest.Success/SYCL_NATIVE_CPU___SYCL_Native_CPU__{{.*}}__UR_EVENT_INFO_COMMAND_QUEUE urEventGetInfoTest.Success/SYCL_NATIVE_CPU___SYCL_Native_CPU__{{.*}}__UR_EVENT_INFO_CONTEXT urEventGetInfoTest.Success/SYCL_NATIVE_CPU___SYCL_Native_CPU__{{.*}}__UR_EVENT_INFO_COMMAND_TYPE diff --git a/test/conformance/exp_command_buffer/exp_command_buffer_adapter_level_zero_v2.match b/test/conformance/exp_command_buffer/exp_command_buffer_adapter_level_zero_v2.match index 7c222d70a6..c4787da327 100644 --- a/test/conformance/exp_command_buffer/exp_command_buffer_adapter_level_zero_v2.match +++ b/test/conformance/exp_command_buffer/exp_command_buffer_adapter_level_zero_v2.match @@ -1,3 +1,4 @@ +{{NONDETERMINISTIC}} BufferFillCommandTest.UpdateParameters/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_ BufferFillCommandTest.UpdateGlobalSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_ BufferFillCommandTest.SeparateUpdateCalls/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_ diff --git a/test/conformance/exp_command_buffer/exp_command_buffer_adapter_native_cpu.match b/test/conformance/exp_command_buffer/exp_command_buffer_adapter_native_cpu.match index 2508f92fed..eeb0aff5cf 100644 --- a/test/conformance/exp_command_buffer/exp_command_buffer_adapter_native_cpu.match +++ b/test/conformance/exp_command_buffer/exp_command_buffer_adapter_native_cpu.match @@ -1,3 +1,4 @@ +{{NONDETERMINISTIC}} {{OPT}}BufferFillCommandTest.UpdateParameters/SYCL_NATIVE_CPU___SYCL_Native_CPU__{{.*}} {{OPT}}BufferFillCommandTest.UpdateGlobalSize/SYCL_NATIVE_CPU___SYCL_Native_CPU__{{.*}} {{OPT}}BufferFillCommandTest.SeparateUpdateCalls/SYCL_NATIVE_CPU___SYCL_Native_CPU__{{.*}} diff --git a/test/conformance/exp_enqueue_native/exp_enqueue_native_adapter_level_zero_v2.match b/test/conformance/exp_enqueue_native/exp_enqueue_native_adapter_level_zero_v2.match index 2c9b3a0f8d..d4645b3ffc 100644 --- a/test/conformance/exp_enqueue_native/exp_enqueue_native_adapter_level_zero_v2.match +++ b/test/conformance/exp_enqueue_native/exp_enqueue_native_adapter_level_zero_v2.match @@ -1,3 +1,4 @@ +{{NONDETERMINISTIC}} urLevelZeroEnqueueNativeCommandTest.Success{{.*}} urLevelZeroEnqueueNativeCommandTest.Dependencies{{.*}} urLevelZeroEnqueueNativeCommandTest.DependenciesURBefore{{.*}} diff --git a/test/conformance/exp_launch_properties/exp_launch_properties_adapter_native_cpu.match b/test/conformance/exp_launch_properties/exp_launch_properties_adapter_native_cpu.match index 2a87dd8c12..f8b1e49e44 100644 --- a/test/conformance/exp_launch_properties/exp_launch_properties_adapter_native_cpu.match +++ b/test/conformance/exp_launch_properties/exp_launch_properties_adapter_native_cpu.match @@ -1 +1,2 @@ +{{NONDETERMINISTIC}} urEnqueueKernelLaunchCustomTest.Success/SYCL_NATIVE_CPU___SYCL_Native_CPU__{{.*}} diff --git a/test/conformance/integration/integration_adapter_level_zero.match b/test/conformance/integration/integration_adapter_level_zero.match index 905fdea60f..a49ad93a94 100644 --- a/test/conformance/integration/integration_adapter_level_zero.match +++ b/test/conformance/integration/integration_adapter_level_zero.match @@ -1,3 +1,4 @@ +{{NONDETERMINISTIC}} {{OPT}}QueueEmptyStatusTestWithParam.QueueEmptyStatusTest/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___IN_ORDER_QUEUE {{OPT}}QueueEmptyStatusTestWithParam.QueueEmptyStatusTest/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___OUT_OF_ORDER_QUEUE {{OPT}}QueueUSMTestWithParam.QueueUSMTest/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___IN_ORDER_QUEUE diff --git a/test/conformance/integration/integration_adapter_level_zero_v2.match b/test/conformance/integration/integration_adapter_level_zero_v2.match index 905fdea60f..a49ad93a94 100644 --- a/test/conformance/integration/integration_adapter_level_zero_v2.match +++ b/test/conformance/integration/integration_adapter_level_zero_v2.match @@ -1,3 +1,4 @@ +{{NONDETERMINISTIC}} {{OPT}}QueueEmptyStatusTestWithParam.QueueEmptyStatusTest/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___IN_ORDER_QUEUE {{OPT}}QueueEmptyStatusTestWithParam.QueueEmptyStatusTest/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___OUT_OF_ORDER_QUEUE {{OPT}}QueueUSMTestWithParam.QueueUSMTest/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___IN_ORDER_QUEUE diff --git a/test/conformance/integration/integration_adapter_native_cpu.match b/test/conformance/integration/integration_adapter_native_cpu.match index d1974de779..b3f1481fa3 100644 --- a/test/conformance/integration/integration_adapter_native_cpu.match +++ b/test/conformance/integration/integration_adapter_native_cpu.match @@ -1,3 +1,4 @@ +{{NONDETERMINISTIC}} QueueEmptyStatusTestWithParam.QueueEmptyStatusTest/SYCL_NATIVE_CPU___SYCL_Native_CPU__{{.*}}__IN_ORDER_QUEUE QueueEmptyStatusTestWithParam.QueueEmptyStatusTest/SYCL_NATIVE_CPU___SYCL_Native_CPU__{{.*}}__OUT_OF_ORDER_QUEUE QueueUSMTestWithParam.QueueUSMTest/SYCL_NATIVE_CPU___SYCL_Native_CPU__{{.*}}__IN_ORDER_QUEUE diff --git a/test/conformance/integration/integration_adapter_opencl.match b/test/conformance/integration/integration_adapter_opencl.match index 57a5299327..e828530cee 100644 --- a/test/conformance/integration/integration_adapter_opencl.match +++ b/test/conformance/integration/integration_adapter_opencl.match @@ -1,3 +1,4 @@ +{{NONDETERMINISTIC}} QueueEmptyStatusTestWithParam.QueueEmptyStatusTest/Intel_R__OpenCL___{{.*}}___IN_ORDER_QUEUE QueueEmptyStatusTestWithParam.QueueEmptyStatusTest/Intel_R__OpenCL___{{.*}}___OUT_OF_ORDER_QUEUE QueueUSMTestWithParam.QueueUSMTest/Intel_R__OpenCL___{{.*}}___IN_ORDER_QUEUE diff --git a/test/conformance/kernel/kernel_adapter_cuda.match b/test/conformance/kernel/kernel_adapter_cuda.match index fe44a34352..b05b2fda58 100644 --- a/test/conformance/kernel/kernel_adapter_cuda.match +++ b/test/conformance/kernel/kernel_adapter_cuda.match @@ -1,3 +1,4 @@ +{{NONDETERMINISTIC}} urKernelGetGroupInfoWgSizeTest.CompileWorkGroupSize/NVIDIA_CUDA_BACKEND___{{.*}}_ {{OPT}}urKernelSetArgLocalTest.InvalidKernelArgumentIndex/NVIDIA_CUDA_BACKEND___{{.*}}_ {{OPT}}urKernelSetArgMemObjTest.InvalidKernelArgumentIndex/NVIDIA_CUDA_BACKEND___{{.*}}_ diff --git a/test/conformance/kernel/kernel_adapter_hip.match b/test/conformance/kernel/kernel_adapter_hip.match index 2cfb81f0c6..4e6ab18293 100644 --- a/test/conformance/kernel/kernel_adapter_hip.match +++ b/test/conformance/kernel/kernel_adapter_hip.match @@ -1,3 +1,4 @@ +{{NONDETERMINISTIC}} urKernelGetGroupInfoWgSizeTest.CompileWorkGroupSize/AMD_HIP_BACKEND___{{.*}}_ urKernelGetInfoTest.Success/AMD_HIP_BACKEND___{{.*}}___UR_KERNEL_INFO_NUM_REGS urKernelSetArgLocalTest.InvalidKernelArgumentIndex/AMD_HIP_BACKEND___{{.*}}_ diff --git a/test/conformance/kernel/kernel_adapter_level_zero.match b/test/conformance/kernel/kernel_adapter_level_zero.match index c448f6363a..cf83e73ff3 100644 --- a/test/conformance/kernel/kernel_adapter_level_zero.match +++ b/test/conformance/kernel/kernel_adapter_level_zero.match @@ -1,3 +1,4 @@ +{{NONDETERMINISTIC}} urKernelSetExecInfoTest.SuccessIndirectAccess/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_ urKernelSetExecInfoUSMPointersTest.SuccessHost/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_ urKernelSetExecInfoUSMPointersTest.SuccessDevice/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_ diff --git a/test/conformance/kernel/kernel_adapter_level_zero_v2.match b/test/conformance/kernel/kernel_adapter_level_zero_v2.match index 074a58720a..8f431b3617 100644 --- a/test/conformance/kernel/kernel_adapter_level_zero_v2.match +++ b/test/conformance/kernel/kernel_adapter_level_zero_v2.match @@ -1,3 +1,4 @@ +{{NONDETERMINISTIC}} urKernelGetInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_FUNCTION_NAME urKernelGetInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_NUM_ARGS urKernelGetInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_REFERENCE_COUNT diff --git a/test/conformance/kernel/kernel_adapter_native_cpu.match b/test/conformance/kernel/kernel_adapter_native_cpu.match index 6e5db6f70f..14238d9edb 100644 --- a/test/conformance/kernel/kernel_adapter_native_cpu.match +++ b/test/conformance/kernel/kernel_adapter_native_cpu.match @@ -1,3 +1,4 @@ +{{NONDETERMINISTIC}} urKernelCreateTest.Success/SYCL_NATIVE_CPU___SYCL_Native_CPU__{{.*}} urKernelCreateTest.InvalidNullHandleProgram/SYCL_NATIVE_CPU___SYCL_Native_CPU__{{.*}} urKernelCreateTest.InvalidNullPointerName/SYCL_NATIVE_CPU___SYCL_Native_CPU__{{.*}} diff --git a/test/conformance/kernel/kernel_adapter_opencl.match b/test/conformance/kernel/kernel_adapter_opencl.match index dfc23cf5ee..d65c8e51c8 100644 --- a/test/conformance/kernel/kernel_adapter_opencl.match +++ b/test/conformance/kernel/kernel_adapter_opencl.match @@ -1 +1,2 @@ +{{NONDETERMINISTIC}} urKernelGetInfoTest.Success/Intel_R__OpenCL_{{.*}}_UR_KERNEL_INFO_NUM_REGS diff --git a/test/conformance/memory/memory_adapter_cuda.match b/test/conformance/memory/memory_adapter_cuda.match index 7d2e6a1c01..c5b70e8559 100644 --- a/test/conformance/memory/memory_adapter_cuda.match +++ b/test/conformance/memory/memory_adapter_cuda.match @@ -1,3 +1,4 @@ +{{NONDETERMINISTIC}} urMemImageCreateTest.InvalidSize/NVIDIA_CUDA_BACKEND___{{.*}}_ {{OPT}}urMemImageCremBufferCrateTestWith1DMemoryTypeParam.Success/NVIDIA_CUDA_BACKEND___{{.*}}___UR_MEM_TYPE_IMAGE1D_ARRAY {{OPT}}urMemImageCreateTestWith2DMemoryTypeParam.Success/NVIDIA_CUDA_BACKEND___{{.*}}___UR_MEM_TYPE_IMAGE2D_ARRAY diff --git a/test/conformance/memory/memory_adapter_hip.match b/test/conformance/memory/memory_adapter_hip.match index a4e1b131f0..589542df7f 100644 --- a/test/conformance/memory/memory_adapter_hip.match +++ b/test/conformance/memory/memory_adapter_hip.match @@ -1,3 +1,4 @@ +{{NONDETERMINISTIC}} urMemImageCreateTest.InvalidSize/AMD_HIP_BACKEND___{{.*}} urMemImageGetInfoTest.Success/AMD_HIP_BACKEND___{{.*}} urMemImageGetInfoTest.Success/AMD_HIP_BACKEND___{{.*}} diff --git a/test/conformance/memory/memory_adapter_level_zero.match b/test/conformance/memory/memory_adapter_level_zero.match index 369bc5e727..f09638fd08 100644 --- a/test/conformance/memory/memory_adapter_level_zero.match +++ b/test/conformance/memory/memory_adapter_level_zero.match @@ -1,3 +1,4 @@ +{{NONDETERMINISTIC}} urMemBufferPartitionTest.InvalidValueCreateType/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_ urMemBufferPartitionTest.InvalidValueBufferCreateInfoOutOfBounds/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_ {{OPT}}urMemGetInfoImageTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_MEM_INFO_SIZE diff --git a/test/conformance/memory/memory_adapter_level_zero_v2.match b/test/conformance/memory/memory_adapter_level_zero_v2.match index e6639680ed..43171a6d8b 100644 --- a/test/conformance/memory/memory_adapter_level_zero_v2.match +++ b/test/conformance/memory/memory_adapter_level_zero_v2.match @@ -1,3 +1,4 @@ +{{NONDETERMINISTIC}} urMemBufferPartitionTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_ urMemBufferPartitionTest.InvalidValueCreateType/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_ urMemBufferPartitionTest.InvalidValueBufferCreateInfoOutOfBounds/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_ diff --git a/test/conformance/memory/memory_adapter_native_cpu.match b/test/conformance/memory/memory_adapter_native_cpu.match index 2fb0814324..5bdd88804b 100644 --- a/test/conformance/memory/memory_adapter_native_cpu.match +++ b/test/conformance/memory/memory_adapter_native_cpu.match @@ -1,3 +1,4 @@ +{{NONDETERMINISTIC}} urMemBufferPartitionTest.InvalidValueCreateType/SYCL_NATIVE_CPU___SYCL_Native_CPU__{{.*}} urMemBufferPartitionTest.InvalidValueBufferCreateInfoOutOfBounds/SYCL_NATIVE_CPU___SYCL_Native_CPU__{{.*}} urMemGetInfoTest.Success/SYCL_NATIVE_CPU___SYCL_Native_CPU__{{.*}}__UR_MEM_INFO_SIZE diff --git a/test/conformance/memory/memory_adapter_opencl.match b/test/conformance/memory/memory_adapter_opencl.match index 23dfbbae8c..b57e3876d0 100644 --- a/test/conformance/memory/memory_adapter_opencl.match +++ b/test/conformance/memory/memory_adapter_opencl.match @@ -1 +1,2 @@ +{{NONDETERMINISTIC}} urMemImageCreateTest.InvalidImageDescStype/Intel_R__OpenCL___{{.*}} diff --git a/test/conformance/platform/platform_adapter_cuda.match b/test/conformance/platform/platform_adapter_cuda.match index b459b89bbe..7806019709 100644 --- a/test/conformance/platform/platform_adapter_cuda.match +++ b/test/conformance/platform/platform_adapter_cuda.match @@ -1 +1,2 @@ +{{NONDETERMINISTIC}} urPlatformCreateWithNativeHandleTest.InvalidNullPointerPlatform diff --git a/test/conformance/platform/platform_adapter_hip.match b/test/conformance/platform/platform_adapter_hip.match index b459b89bbe..7806019709 100644 --- a/test/conformance/platform/platform_adapter_hip.match +++ b/test/conformance/platform/platform_adapter_hip.match @@ -1 +1,2 @@ +{{NONDETERMINISTIC}} urPlatformCreateWithNativeHandleTest.InvalidNullPointerPlatform diff --git a/test/conformance/platform/platform_adapter_native_cpu.match b/test/conformance/platform/platform_adapter_native_cpu.match index b459b89bbe..7806019709 100644 --- a/test/conformance/platform/platform_adapter_native_cpu.match +++ b/test/conformance/platform/platform_adapter_native_cpu.match @@ -1 +1,2 @@ +{{NONDETERMINISTIC}} urPlatformCreateWithNativeHandleTest.InvalidNullPointerPlatform diff --git a/test/conformance/program/program_adapter_cuda.match b/test/conformance/program/program_adapter_cuda.match index 5ffc32bb03..4e9d452f44 100644 --- a/test/conformance/program/program_adapter_cuda.match +++ b/test/conformance/program/program_adapter_cuda.match @@ -1,3 +1,4 @@ +{{NONDETERMINISTIC}} urProgramBuildTest.BuildFailure/NVIDIA_CUDA_BACKEND___{{.*}}_ {{OPT}}urProgramCreateWithILTest.Success/NVIDIA_CUDA_BACKEND___{{.*}} {{OPT}}urProgramCreateWithILTest.SuccessWithProperties/NVIDIA_CUDA_BACKEND___{{.*}} diff --git a/test/conformance/program/program_adapter_hip.match b/test/conformance/program/program_adapter_hip.match index 183d88342d..9ddc01f1f7 100644 --- a/test/conformance/program/program_adapter_hip.match +++ b/test/conformance/program/program_adapter_hip.match @@ -1,3 +1,4 @@ +{{NONDETERMINISTIC}} urProgramBuildTest.BuildFailure/AMD_HIP_BACKEND___{{.*}}_ # HIP hasn't implemented urProgramCreateWithNativeHandleTest {{OPT}}urProgramCreateWithNativeHandleTest.Success/AMD_HIP_BACKEND___{{.*}}_ diff --git a/test/conformance/program/program_adapter_level_zero.match b/test/conformance/program/program_adapter_level_zero.match index f8d65b426e..622c187ea3 100644 --- a/test/conformance/program/program_adapter_level_zero.match +++ b/test/conformance/program/program_adapter_level_zero.match @@ -1,3 +1,4 @@ +{{NONDETERMINISTIC}} urProgramCreateWithNativeHandleTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_ urProgramCreateWithNativeHandleTest.InvalidNullHandleContext/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_ urProgramCreateWithNativeHandleTest.InvalidNullPointerProgram/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_ diff --git a/test/conformance/program/program_adapter_level_zero_v2.match b/test/conformance/program/program_adapter_level_zero_v2.match index 70e0a12609..76e1fbddf0 100644 --- a/test/conformance/program/program_adapter_level_zero_v2.match +++ b/test/conformance/program/program_adapter_level_zero_v2.match @@ -1,3 +1,4 @@ +{{NONDETERMINISTIC}} urProgramCreateWithNativeHandleTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_ urProgramCreateWithNativeHandleTest.InvalidNullHandleContext/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_ urProgramCreateWithNativeHandleTest.InvalidNullPointerProgram/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_ diff --git a/test/conformance/program/program_adapter_native_cpu.match b/test/conformance/program/program_adapter_native_cpu.match index cf3fa7062d..f9aeace343 100644 --- a/test/conformance/program/program_adapter_native_cpu.match +++ b/test/conformance/program/program_adapter_native_cpu.match @@ -1,3 +1,4 @@ +{{NONDETERMINISTIC}} {{OPT}}urProgramBuildTest.Success/SYCL_NATIVE_CPU___SYCL_Native_CPU__{{.*}} {{OPT}}urProgramBuildTest.SuccessWithOptions/SYCL_NATIVE_CPU___SYCL_Native_CPU__{{.*}} {{OPT}}urProgramBuildTest.InvalidNullHandleContext/SYCL_NATIVE_CPU___SYCL_Native_CPU__{{.*}} diff --git a/test/conformance/program/program_adapter_opencl.match b/test/conformance/program/program_adapter_opencl.match index a4b56d4f94..4aba3fe63d 100644 --- a/test/conformance/program/program_adapter_opencl.match +++ b/test/conformance/program/program_adapter_opencl.match @@ -1,2 +1,3 @@ +{{NONDETERMINISTIC}} urProgramCreateWithILTest.BuildInvalidProgram/Intel_R__OpenCL___{{.*}}_ urProgramGetInfoTest.Success/Intel_R__OpenCL___{{.*}}___UR_PROGRAM_INFO_SOURCE diff --git a/test/conformance/queue/queue_adapter_native_cpu.match b/test/conformance/queue/queue_adapter_native_cpu.match index 1d17a6fa38..32ea573390 100644 --- a/test/conformance/queue/queue_adapter_native_cpu.match +++ b/test/conformance/queue/queue_adapter_native_cpu.match @@ -1,3 +1,4 @@ +{{NONDETERMINISTIC}} urQueueCreateTest.Success/SYCL_NATIVE_CPU___SYCL_Native_CPU__{{.*}} urQueueCreateTest.CheckContext/SYCL_NATIVE_CPU___SYCL_Native_CPU__{{.*}} urQueueCreateWithParamTest.SuccessWithProperties/SYCL_NATIVE_CPU___SYCL_Native_CPU__{{.*}}__UR_QUEUE_FLAG_OUT_OF_ORDER_EXEC_MODE_ENABLE diff --git a/test/conformance/sampler/sampler_adapter_level_zero.match b/test/conformance/sampler/sampler_adapter_level_zero.match index 1508bd1f8b..f1b3485529 100644 --- a/test/conformance/sampler/sampler_adapter_level_zero.match +++ b/test/conformance/sampler/sampler_adapter_level_zero.match @@ -1,3 +1,4 @@ +{{NONDETERMINISTIC}} {{OPT}}urSamplerGetInfoTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_SAMPLER_INFO_REFERENCE_COUNT {{OPT}}urSamplerGetInfoTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_SAMPLER_INFO_CONTEXT {{OPT}}urSamplerGetInfoTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_SAMPLER_INFO_NORMALIZED_COORDS diff --git a/test/conformance/sampler/sampler_adapter_level_zero_v2.match b/test/conformance/sampler/sampler_adapter_level_zero_v2.match index 1508bd1f8b..f1b3485529 100644 --- a/test/conformance/sampler/sampler_adapter_level_zero_v2.match +++ b/test/conformance/sampler/sampler_adapter_level_zero_v2.match @@ -1,3 +1,4 @@ +{{NONDETERMINISTIC}} {{OPT}}urSamplerGetInfoTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_SAMPLER_INFO_REFERENCE_COUNT {{OPT}}urSamplerGetInfoTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_SAMPLER_INFO_CONTEXT {{OPT}}urSamplerGetInfoTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_SAMPLER_INFO_NORMALIZED_COORDS diff --git a/test/conformance/usm/usm_adapter_cuda.match b/test/conformance/usm/usm_adapter_cuda.match index 15b68f5c6c..a9f7c37b87 100644 --- a/test/conformance/usm/usm_adapter_cuda.match +++ b/test/conformance/usm/usm_adapter_cuda.match @@ -1,3 +1,4 @@ +{{NONDETERMINISTIC}} {{OPT}}urUSMDeviceAllocTest.InvalidUSMSize/NVIDIA_CUDA_BACKEND___{{.*}}___UsePoolEnabled {{OPT}}urUSMDeviceAllocTest.InvalidUSMSize/NVIDIA_CUDA_BACKEND___{{.*}}___UsePoolDisabled {{OPT}}urUSMHostAllocTest.InvalidUSMSize/NVIDIA_CUDA_BACKEND___{{.*}}___UsePoolEnabled diff --git a/test/conformance/usm/usm_adapter_hip.match b/test/conformance/usm/usm_adapter_hip.match index 2dfdaf7253..5a1be3c9d4 100644 --- a/test/conformance/usm/usm_adapter_hip.match +++ b/test/conformance/usm/usm_adapter_hip.match @@ -1,3 +1,4 @@ +{{NONDETERMINISTIC}} urUSMDeviceAllocTest.Success/AMD_HIP_BACKEND___{{.*}}___UsePoolEnabled urUSMDeviceAllocTest.SuccessWithDescriptors/AMD_HIP_BACKEND___{{.*}}___UsePoolEnabled urUSMDeviceAllocTest.InvalidNullHandleContext/AMD_HIP_BACKEND___{{.*}}___UsePoolEnabled diff --git a/test/conformance/usm/usm_adapter_level_zero.match b/test/conformance/usm/usm_adapter_level_zero.match index c036fa785c..6f2d5ab1f9 100644 --- a/test/conformance/usm/usm_adapter_level_zero.match +++ b/test/conformance/usm/usm_adapter_level_zero.match @@ -1,2 +1,3 @@ +{{NONDETERMINISTIC}} {{OPT}}urUSMDeviceAllocTest.InvalidUSMSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled {{OPT}}urUSMDeviceAllocTest.InvalidUSMSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled diff --git a/test/conformance/usm/usm_adapter_level_zero_v2.match b/test/conformance/usm/usm_adapter_level_zero_v2.match index 0908da40da..85f9c4e5c0 100644 --- a/test/conformance/usm/usm_adapter_level_zero_v2.match +++ b/test/conformance/usm/usm_adapter_level_zero_v2.match @@ -1,3 +1,4 @@ +{{NONDETERMINISTIC}} urUSMDeviceAllocTest.InvalidUSMSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled urUSMDeviceAllocTest.InvalidUSMSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled urUSMGetMemAllocInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_USM_ALLOC_INFO_POOL diff --git a/test/conformance/usm/usm_adapter_native_cpu.match b/test/conformance/usm/usm_adapter_native_cpu.match index 13a0adbdf3..84d214c97f 100644 --- a/test/conformance/usm/usm_adapter_native_cpu.match +++ b/test/conformance/usm/usm_adapter_native_cpu.match @@ -1,3 +1,4 @@ +{{NONDETERMINISTIC}} urUSMDeviceAllocTest.Success/SYCL_NATIVE_CPU___SYCL_Native_CPU__{{.*}}__UsePoolEnabled urUSMDeviceAllocTest.Success/SYCL_NATIVE_CPU___SYCL_Native_CPU__{{.*}}__UsePoolDisabled urUSMDeviceAllocTest.SuccessWithDescriptors/SYCL_NATIVE_CPU___SYCL_Native_CPU__{{.*}}__UsePoolEnabled diff --git a/test/conformance/usm/usm_adapter_opencl.match b/test/conformance/usm/usm_adapter_opencl.match index cb00bebc57..fbaba92f30 100644 --- a/test/conformance/usm/usm_adapter_opencl.match +++ b/test/conformance/usm/usm_adapter_opencl.match @@ -1,3 +1,4 @@ +{{NONDETERMINISTIC}} urUSMDeviceAllocTest.Success/Intel_R__OpenCL___{{.*}}___UsePoolEnabled urUSMDeviceAllocTest.SuccessWithDescriptors/Intel_R__OpenCL___{{.*}}___UsePoolEnabled urUSMDeviceAllocTest.InvalidNullHandleContext/Intel_R__OpenCL___{{.*}}___UsePoolEnabled diff --git a/test/conformance/virtual_memory/virtual_memory_adapter_level_zero.match b/test/conformance/virtual_memory/virtual_memory_adapter_level_zero.match index 9cda954748..bf8c7ce279 100644 --- a/test/conformance/virtual_memory/virtual_memory_adapter_level_zero.match +++ b/test/conformance/virtual_memory/virtual_memory_adapter_level_zero.match @@ -1,3 +1,4 @@ +{{NONDETERMINISTIC}} {{OPT}}urPhysicalMemCreateTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___3 {{OPT}}urPhysicalMemCreateTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___7 {{OPT}}urPhysicalMemCreateTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___12 diff --git a/test/conformance/virtual_memory/virtual_memory_adapter_level_zero_v2.match b/test/conformance/virtual_memory/virtual_memory_adapter_level_zero_v2.match index f98e5ac28f..1c83fd1e2a 100644 --- a/test/conformance/virtual_memory/virtual_memory_adapter_level_zero_v2.match +++ b/test/conformance/virtual_memory/virtual_memory_adapter_level_zero_v2.match @@ -1,4 +1,4 @@ - +{{NONDETERMINISTIC}} urPhysicalMemCreateTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1 urPhysicalMemCreateTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2 urPhysicalMemCreateTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___3 From 854cb879810f94a5a6658b98a7efad0f5d2d1688 Mon Sep 17 00:00:00 2001 From: Winston Zhang Date: Fri, 31 May 2024 16:49:16 -0700 Subject: [PATCH 18/36] [L0] Phase 2 of Counter-Based Event Implementation -enable counter-based events for regular commandlist -counter-based events may be reused even though they are not done -when ref count goes to not used by external clients value it means that event may be reused by subsequent calls -move events that are no longer externally visible to re-usable pool and reuse those more aggressively Signed-off-by: Winston Zhang --- source/adapters/level_zero/context.cpp | 20 ++++++++--- source/adapters/level_zero/context.hpp | 49 ++++++++++++++++++++------ source/adapters/level_zero/event.cpp | 12 ++++--- source/adapters/level_zero/queue.cpp | 2 +- 4 files changed, 62 insertions(+), 21 deletions(-) diff --git a/source/adapters/level_zero/context.cpp b/source/adapters/level_zero/context.cpp index 296e3e98d5..0a68be4f24 100644 --- a/source/adapters/level_zero/context.cpp +++ b/source/adapters/level_zero/context.cpp @@ -560,9 +560,12 @@ ur_result_t ur_context_handle_t_::getFreeSlotInExistingOrNewPool( ur_event_handle_t ur_context_handle_t_::getEventFromContextCache( bool HostVisible, bool WithProfiling, ur_device_handle_t Device, - bool CounterBasedEventEnabled) { + bool CounterBasedEventEnabled, bool UsingImmCmdList) { std::scoped_lock Lock(EventCacheMutex); auto Cache = getEventCache(HostVisible, WithProfiling, Device); + if (CounterBasedEventEnabled) { + Cache = getCounterBasedEventCache(UsingImmCmdList, Device); + } if (Cache->empty()) return nullptr; @@ -573,7 +576,8 @@ ur_event_handle_t ur_context_handle_t_::getEventFromContextCache( } Cache->erase(It); // We have to reset event before using it. - Event->reset(); + if (!CounterBasedEventEnabled) + Event->reset(); return Event; } @@ -585,9 +589,15 @@ void ur_context_handle_t_::addEventToContextCache(ur_event_handle_t Event) { Device = Event->UrQueue->Device; } - auto Cache = getEventCache(Event->isHostVisible(), - Event->isProfilingEnabled(), Device); - Cache->emplace_back(Event); + if (!Event->CounterBasedEventsEnabled) { + auto Cache = getCounterBasedEventCache( + !Event->UrQueue || Event->UrQueue->UsingImmCmdLists, Device); + Cache->emplace_back(Event); + } else { + auto Cache = getEventCache(Event->isHostVisible(), + Event->isProfilingEnabled(), Device); + Cache->emplace_back(Event); + } } ur_result_t diff --git a/source/adapters/level_zero/context.hpp b/source/adapters/level_zero/context.hpp index c2fbba633f..2b8d8beab2 100644 --- a/source/adapters/level_zero/context.hpp +++ b/source/adapters/level_zero/context.hpp @@ -171,9 +171,9 @@ struct ur_context_handle_t_ : _ur_object { // Caches for events. using EventCache = std::vector>; - EventCache EventCaches{4}; + EventCache EventCaches{6}; std::vector> - EventCachesDeviceMap{4}; + EventCachesDeviceMap{6}; // Initialize the PI context. ur_result_t initialize(); @@ -208,10 +208,10 @@ struct ur_context_handle_t_ : _ur_object { bool UsingImmCmdList); // Get ur_event_handle_t from cache. - ur_event_handle_t getEventFromContextCache(bool HostVisible, - bool WithProfiling, - ur_device_handle_t Device, - bool CounterBasedEventEnabled); + ur_event_handle_t + getEventFromContextCache(bool HostVisible, bool WithProfiling, + ur_device_handle_t Device, + bool CounterBasedEventEnabled bool UsingImmCmdList); // Add ur_event_handle_t to cache. void addEventToContextCache(ur_event_handle_t); @@ -341,9 +341,36 @@ struct ur_context_handle_t_ : _ur_object { } } } -}; + auto getCounterBasedEventCache(bool UsingImmediateCmdList, + ur_device_handle_t Device) { + if (UsingImmediateCmdList) { + if (Device) { + auto EventCachesMap = &EventCachesDeviceMap[4]; + if (EventCachesMap->find(Device) == EventCachesMap->end()) { + EventCaches.emplace_back(); + EventCachesMap->insert( + std::make_pair(Device, EventCaches.size() - 1)); + } + return &EventCaches[(*EventCachesMap)[Device]]; + } else { + return &EventCaches[4]; + } + } else { + if (Device) { + auto EventCachesMap = &EventCachesDeviceMap[5]; + if (EventCachesMap->find(Device) == EventCachesMap->end()) { + EventCaches.emplace_back(); + EventCachesMap->insert( + std::make_pair(Device, EventCaches.size() - 1)); + } + return &EventCaches[(*EventCachesMap)[Device]]; + } else { + return &EventCaches[5]; + } + } + }; -// Helper function to release the context, a caller must lock the platform-level -// mutex guarding the container with contexts because the context can be removed -// from the list of tracked contexts. -ur_result_t ContextReleaseHelper(ur_context_handle_t Context); + // Helper function to release the context, a caller must lock the + // platform-level mutex guarding the container with contexts because the + // context can be removed from the list of tracked contexts. + ur_result_t ContextReleaseHelper(ur_context_handle_t Context); diff --git a/source/adapters/level_zero/event.cpp b/source/adapters/level_zero/event.cpp index f58db37753..3e012645a6 100644 --- a/source/adapters/level_zero/event.cpp +++ b/source/adapters/level_zero/event.cpp @@ -834,8 +834,11 @@ ur_result_t urEventRelease(ur_event_handle_t Event ///< [in] handle of the event object ) { Event->RefCountExternal--; - UR_CALL(urEventReleaseInternal(Event)); - + if (Event->CounterBasedEventsEnabled && Event->RefCountExternal == 0) { + Event->Context->addEventToContextCache(Event); + } else { + UR_CALL(urEventReleaseInternal(Event)); + } return UR_RESULT_SUCCESS; } @@ -995,7 +998,7 @@ ur_result_t ur_event_handle_t_::getOrCreateHostVisibleEvent( } ur_result_t urEventReleaseInternal(ur_event_handle_t Event) { - if (!Event->RefCount.decrementAndTest()) + if (!Event->CounterBasedEventsEnabled && !Event->RefCount.decrementAndTest()) return UR_RESULT_SUCCESS; if (Event->CommandType == UR_COMMAND_MEM_UNMAP && Event->CommandData) { @@ -1257,7 +1260,8 @@ ur_result_t EventCreate(ur_context_handle_t Context, ur_queue_handle_t Queue, } if (auto CachedEvent = Context->getEventFromContextCache( - HostVisible, ProfilingEnabled, Device, CounterBasedEventEnabled)) { + HostVisible, ProfilingEnabled, Device, CounterBasedEventEnabled, + UsingImmediateCommandlists)) { *RetEvent = CachedEvent; return UR_RESULT_SUCCESS; } diff --git a/source/adapters/level_zero/queue.cpp b/source/adapters/level_zero/queue.cpp index 978547df10..b498992bdd 100644 --- a/source/adapters/level_zero/queue.cpp +++ b/source/adapters/level_zero/queue.cpp @@ -1187,7 +1187,7 @@ ur_queue_handle_t_::ur_queue_handle_t_( return std::atoi(UrRet) != 0; }(); this->CounterBasedEventsEnabled = - UsingImmCmdLists && isInOrderQueue() && Device->useDriverInOrderLists() && + isInOrderQueue() && Device->useDriverInOrderLists() && useDriverCounterBasedEvents && Device->Platform->ZeDriverEventPoolCountingEventsExtensionFound; } From 07cae8d356d6f3d8260284f68ca07e186606f6f1 Mon Sep 17 00:00:00 2001 From: Winston Zhang Date: Mon, 10 Jun 2024 12:18:23 -0700 Subject: [PATCH 19/36] [L0] Fixed a few syntax and scope errors Signed-off-by: Winston Zhang --- source/adapters/level_zero/context.cpp | 2 +- source/adapters/level_zero/context.hpp | 22 ++++++++++++---------- source/adapters/level_zero/event.cpp | 2 +- 3 files changed, 14 insertions(+), 12 deletions(-) diff --git a/source/adapters/level_zero/context.cpp b/source/adapters/level_zero/context.cpp index 0a68be4f24..dba47d77eb 100644 --- a/source/adapters/level_zero/context.cpp +++ b/source/adapters/level_zero/context.cpp @@ -589,7 +589,7 @@ void ur_context_handle_t_::addEventToContextCache(ur_event_handle_t Event) { Device = Event->UrQueue->Device; } - if (!Event->CounterBasedEventsEnabled) { + if (Event->CounterBasedEventsEnabled) { auto Cache = getCounterBasedEventCache( !Event->UrQueue || Event->UrQueue->UsingImmCmdLists, Device); Cache->emplace_back(Event); diff --git a/source/adapters/level_zero/context.hpp b/source/adapters/level_zero/context.hpp index 2b8d8beab2..fc970e35d3 100644 --- a/source/adapters/level_zero/context.hpp +++ b/source/adapters/level_zero/context.hpp @@ -208,10 +208,11 @@ struct ur_context_handle_t_ : _ur_object { bool UsingImmCmdList); // Get ur_event_handle_t from cache. - ur_event_handle_t - getEventFromContextCache(bool HostVisible, bool WithProfiling, - ur_device_handle_t Device, - bool CounterBasedEventEnabled bool UsingImmCmdList); + ur_event_handle_t getEventFromContextCache(bool HostVisible, + bool WithProfiling, + ur_device_handle_t Device, + bool CounterBasedEventEnabled, + bool UsingImmCmdList); // Add ur_event_handle_t to cache. void addEventToContextCache(ur_event_handle_t); @@ -340,7 +341,7 @@ struct ur_context_handle_t_ : _ur_object { return WithProfiling ? &EventCaches[2] : &EventCaches[3]; } } - } + }; auto getCounterBasedEventCache(bool UsingImmediateCmdList, ur_device_handle_t Device) { if (UsingImmediateCmdList) { @@ -368,9 +369,10 @@ struct ur_context_handle_t_ : _ur_object { return &EventCaches[5]; } } - }; + } +}; - // Helper function to release the context, a caller must lock the - // platform-level mutex guarding the container with contexts because the - // context can be removed from the list of tracked contexts. - ur_result_t ContextReleaseHelper(ur_context_handle_t Context); +// Helper function to release the context, a caller must lock the +// platform-level mutex guarding the container with contexts because the +// context can be removed from the list of tracked contexts. +ur_result_t ContextReleaseHelper(ur_context_handle_t Context); diff --git a/source/adapters/level_zero/event.cpp b/source/adapters/level_zero/event.cpp index 3e012645a6..7a7728e818 100644 --- a/source/adapters/level_zero/event.cpp +++ b/source/adapters/level_zero/event.cpp @@ -998,7 +998,7 @@ ur_result_t ur_event_handle_t_::getOrCreateHostVisibleEvent( } ur_result_t urEventReleaseInternal(ur_event_handle_t Event) { - if (!Event->CounterBasedEventsEnabled && !Event->RefCount.decrementAndTest()) + if (!Event->RefCount.decrementAndTest()) return UR_RESULT_SUCCESS; if (Event->CommandType == UR_COMMAND_MEM_UNMAP && Event->CommandData) { From 54e4ff98acd027b38fd3d4460adacb5756f3d3a8 Mon Sep 17 00:00:00 2001 From: Winston Zhang Date: Mon, 17 Jun 2024 11:58:18 -0700 Subject: [PATCH 20/36] [L0] Changed atomic value comparison Signed-off-by: Winston Zhang --- source/adapters/level_zero/event.cpp | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/source/adapters/level_zero/event.cpp b/source/adapters/level_zero/event.cpp index 7a7728e818..edc978f291 100644 --- a/source/adapters/level_zero/event.cpp +++ b/source/adapters/level_zero/event.cpp @@ -833,8 +833,7 @@ urEventRetain(ur_event_handle_t Event ///< [in] handle of the event object ur_result_t urEventRelease(ur_event_handle_t Event ///< [in] handle of the event object ) { - Event->RefCountExternal--; - if (Event->CounterBasedEventsEnabled && Event->RefCountExternal == 0) { + if (Event->CounterBasedEventsEnabled && --Event->RefCountExternal == 0) { Event->Context->addEventToContextCache(Event); } else { UR_CALL(urEventReleaseInternal(Event)); From 3e07707bbcf5b513d685f862ce1d42f5bdf05bba Mon Sep 17 00:00:00 2001 From: Winston Zhang Date: Mon, 1 Jul 2024 23:55:41 -0700 Subject: [PATCH 21/36] [L0] Rebased against top of main Signed-off-by: Winston Zhang --- source/adapters/level_zero/context.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/source/adapters/level_zero/context.cpp b/source/adapters/level_zero/context.cpp index dba47d77eb..197c54dc3f 100644 --- a/source/adapters/level_zero/context.cpp +++ b/source/adapters/level_zero/context.cpp @@ -591,7 +591,8 @@ void ur_context_handle_t_::addEventToContextCache(ur_event_handle_t Event) { if (Event->CounterBasedEventsEnabled) { auto Cache = getCounterBasedEventCache( - !Event->UrQueue || Event->UrQueue->UsingImmCmdLists, Device); + !Legacy(Event->UrQueue) || Legacy(Event->UrQueue)->UsingImmCmdLists, + Device); Cache->emplace_back(Event); } else { auto Cache = getEventCache(Event->isHostVisible(), From 697d908a9f32a45ef883726d88cd45c0d49cab8e Mon Sep 17 00:00:00 2001 From: Winston Zhang Date: Tue, 9 Jul 2024 18:14:56 -0700 Subject: [PATCH 22/36] [L0] fixes cache map insert and add enum to make code more readable Signed-off-by: Winston Zhang --- source/adapters/level_zero/context.hpp | 43 ++++++++++++++++---------- source/adapters/level_zero/event.cpp | 2 +- 2 files changed, 28 insertions(+), 17 deletions(-) diff --git a/source/adapters/level_zero/context.hpp b/source/adapters/level_zero/context.hpp index fc970e35d3..c6c12e27e7 100644 --- a/source/adapters/level_zero/context.hpp +++ b/source/adapters/level_zero/context.hpp @@ -311,34 +311,45 @@ struct ur_context_handle_t_ : _ur_object { ze_context_handle_t getZeHandle() const; private: + enum EventCacheType { + HostVisibleProfilingCacheType, + HostVisibleRegularCacheType, + HostInvisibleProfilingCacheType, + HostInvisibleRegularCacheType, + CounterBasedRegularCacheType, + CounterBasedImmediateCacheType + }; // Get the cache of events for a provided scope and profiling mode. auto getEventCache(bool HostVisible, bool WithProfiling, ur_device_handle_t Device) { if (HostVisible) { if (Device) { auto EventCachesMap = - WithProfiling ? &EventCachesDeviceMap[0] : &EventCachesDeviceMap[1]; + WithProfiling ? &EventCachesDeviceMap[HostVisibleProfilingCacheType] + : &EventCachesDeviceMap[HostVisibleRegularCacheType]; if (EventCachesMap->find(Device) == EventCachesMap->end()) { EventCaches.emplace_back(); - EventCachesMap->insert( - std::make_pair(Device, EventCaches.size() - 1)); + EventCaches.insert(std::make_pair(Device, EventCaches.size() - 1)); } return &EventCaches[(*EventCachesMap)[Device]]; } else { - return WithProfiling ? &EventCaches[0] : &EventCaches[1]; + return WithProfiling ? &EventCaches[HostVisibleProfilingCacheType] + : &EventCaches[HostVisibleRegularCacheType]; } } else { if (Device) { auto EventCachesMap = - WithProfiling ? &EventCachesDeviceMap[2] : &EventCachesDeviceMap[3]; + WithProfiling + ? &EventCachesDeviceMap[HostInvisibleProfilingCacheType] + : &EventCachesDeviceMap[HostInvisibleRegularCacheType]; if (EventCachesMap->find(Device) == EventCachesMap->end()) { EventCaches.emplace_back(); - EventCachesMap->insert( - std::make_pair(Device, EventCaches.size() - 1)); + EventCaches.insert(std::make_pair(Device, EventCaches.size() - 1)); } return &EventCaches[(*EventCachesMap)[Device]]; } else { - return WithProfiling ? &EventCaches[2] : &EventCaches[3]; + return WithProfiling ? &EventCaches[HostInvisibleProfilingCacheType] + : &EventCaches[HostInvisibleRegularCacheType]; } } }; @@ -346,27 +357,27 @@ struct ur_context_handle_t_ : _ur_object { ur_device_handle_t Device) { if (UsingImmediateCmdList) { if (Device) { - auto EventCachesMap = &EventCachesDeviceMap[4]; + auto EventCachesMap = + &EventCachesDeviceMap[CounterBasedImmediateCacheType]; if (EventCachesMap->find(Device) == EventCachesMap->end()) { EventCaches.emplace_back(); - EventCachesMap->insert( - std::make_pair(Device, EventCaches.size() - 1)); + EventCaches.insert(std::make_pair(Device, EventCaches.size() - 1)); } return &EventCaches[(*EventCachesMap)[Device]]; } else { - return &EventCaches[4]; + return &EventCaches[CounterBasedImmediateCacheType]; } } else { if (Device) { - auto EventCachesMap = &EventCachesDeviceMap[5]; + auto EventCachesMap = + &EventCachesDeviceMap[CounterBasedRegularCacheType]; if (EventCachesMap->find(Device) == EventCachesMap->end()) { EventCaches.emplace_back(); - EventCachesMap->insert( - std::make_pair(Device, EventCaches.size() - 1)); + EventCaches.insert(std::make_pair(Device, EventCaches.size() - 1)); } return &EventCaches[(*EventCachesMap)[Device]]; } else { - return &EventCaches[5]; + return &EventCaches[CounterBasedRegularCacheType]; } } } diff --git a/source/adapters/level_zero/event.cpp b/source/adapters/level_zero/event.cpp index edc978f291..30dcce94db 100644 --- a/source/adapters/level_zero/event.cpp +++ b/source/adapters/level_zero/event.cpp @@ -833,7 +833,7 @@ urEventRetain(ur_event_handle_t Event ///< [in] handle of the event object ur_result_t urEventRelease(ur_event_handle_t Event ///< [in] handle of the event object ) { - if (Event->CounterBasedEventsEnabled && --Event->RefCountExternal == 0) { + if (--Event->RefCountExternal == 0 && Event->CounterBasedEventsEnabled) { Event->Context->addEventToContextCache(Event); } else { UR_CALL(urEventReleaseInternal(Event)); From 32f50711449e66a263cca5abff728001044afa56 Mon Sep 17 00:00:00 2001 From: Winston Zhang Date: Tue, 9 Jul 2024 18:20:24 -0700 Subject: [PATCH 23/36] [L0] Fixes syntax Signed-off-by: Winston Zhang --- source/adapters/level_zero/context.hpp | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/source/adapters/level_zero/context.hpp b/source/adapters/level_zero/context.hpp index c6c12e27e7..cb7742a350 100644 --- a/source/adapters/level_zero/context.hpp +++ b/source/adapters/level_zero/context.hpp @@ -329,7 +329,8 @@ struct ur_context_handle_t_ : _ur_object { : &EventCachesDeviceMap[HostVisibleRegularCacheType]; if (EventCachesMap->find(Device) == EventCachesMap->end()) { EventCaches.emplace_back(); - EventCaches.insert(std::make_pair(Device, EventCaches.size() - 1)); + EventCachesMap->insert( + std::make_pair(Device, EventCaches.size() - 1)); } return &EventCaches[(*EventCachesMap)[Device]]; } else { @@ -344,7 +345,8 @@ struct ur_context_handle_t_ : _ur_object { : &EventCachesDeviceMap[HostInvisibleRegularCacheType]; if (EventCachesMap->find(Device) == EventCachesMap->end()) { EventCaches.emplace_back(); - EventCaches.insert(std::make_pair(Device, EventCaches.size() - 1)); + EventCachesMap->insert( + std::make_pair(Device, EventCaches.size() - 1)); } return &EventCaches[(*EventCachesMap)[Device]]; } else { @@ -361,7 +363,8 @@ struct ur_context_handle_t_ : _ur_object { &EventCachesDeviceMap[CounterBasedImmediateCacheType]; if (EventCachesMap->find(Device) == EventCachesMap->end()) { EventCaches.emplace_back(); - EventCaches.insert(std::make_pair(Device, EventCaches.size() - 1)); + EventCachesMap->insert( + std::make_pair(Device, EventCaches.size() - 1)); } return &EventCaches[(*EventCachesMap)[Device]]; } else { @@ -373,7 +376,8 @@ struct ur_context_handle_t_ : _ur_object { &EventCachesDeviceMap[CounterBasedRegularCacheType]; if (EventCachesMap->find(Device) == EventCachesMap->end()) { EventCaches.emplace_back(); - EventCaches.insert(std::make_pair(Device, EventCaches.size() - 1)); + EventCachesMap->insert( + std::make_pair(Device, EventCaches.size() - 1)); } return &EventCaches[(*EventCachesMap)[Device]]; } else { From 51ce97a64e2d4d84e42bf0a4cbb62090bd76c811 Mon Sep 17 00:00:00 2001 From: Winston Zhang Date: Thu, 11 Jul 2024 07:15:33 -0700 Subject: [PATCH 24/36] [L0] better naming for enums Signed-off-by: Winston Zhang --- source/adapters/level_zero/context.hpp | 23 ++++++++++++----------- 1 file changed, 12 insertions(+), 11 deletions(-) diff --git a/source/adapters/level_zero/context.hpp b/source/adapters/level_zero/context.hpp index cb7742a350..0b8f904cb3 100644 --- a/source/adapters/level_zero/context.hpp +++ b/source/adapters/level_zero/context.hpp @@ -217,7 +217,7 @@ struct ur_context_handle_t_ : _ur_object { // Add ur_event_handle_t to cache. void addEventToContextCache(ur_event_handle_t); - enum EventPoolCacheType { + enum ZeEventPoolCacheType { HostVisibleCacheType, HostInvisibleCacheType, HostVisibleCounterBasedRegularCacheType, @@ -226,11 +226,20 @@ struct ur_context_handle_t_ : _ur_object { HostInvisibleCounterBasedImmediateCacheType }; + enum EventCacheType { + HostVisibleProfilingCacheType, + HostVisibleRegularCacheType, + HostInvisibleProfilingCacheType, + HostInvisibleRegularCacheType, + CounterBasedImmediateCacheType, + CounterBasedRegularCacheType + }; + std::list * getZeEventPoolCache(bool HostVisible, bool WithProfiling, bool CounterBasedEventEnabled, bool UsingImmediateCmdList, ze_device_handle_t ZeDevice) { - EventPoolCacheType CacheType; + ZeEventPoolCacheType CacheType; calculateCacheIndex(HostVisible, CounterBasedEventEnabled, UsingImmediateCmdList, CacheType); @@ -253,7 +262,7 @@ struct ur_context_handle_t_ : _ur_object { ur_result_t calculateCacheIndex(bool HostVisible, bool CounterBasedEventEnabled, bool UsingImmediateCmdList, - EventPoolCacheType &CacheType) { + ZeEventPoolCacheType &CacheType) { if (CounterBasedEventEnabled && HostVisible && !UsingImmediateCmdList) { CacheType = HostVisibleCounterBasedRegularCacheType; } else if (CounterBasedEventEnabled && !HostVisible && @@ -311,14 +320,6 @@ struct ur_context_handle_t_ : _ur_object { ze_context_handle_t getZeHandle() const; private: - enum EventCacheType { - HostVisibleProfilingCacheType, - HostVisibleRegularCacheType, - HostInvisibleProfilingCacheType, - HostInvisibleRegularCacheType, - CounterBasedRegularCacheType, - CounterBasedImmediateCacheType - }; // Get the cache of events for a provided scope and profiling mode. auto getEventCache(bool HostVisible, bool WithProfiling, ur_device_handle_t Device) { From 5c9de5a2a084b3ca54c945271d032ae114df5324 Mon Sep 17 00:00:00 2001 From: Winston Zhang Date: Mon, 22 Jul 2024 17:04:24 -0700 Subject: [PATCH 25/36] [L0] Refactored against in-order list to enable CB event by default Signed-off-by: Winston Zhang --- source/adapters/level_zero/context.hpp | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-) diff --git a/source/adapters/level_zero/context.hpp b/source/adapters/level_zero/context.hpp index 0b8f904cb3..b92c08d3a6 100644 --- a/source/adapters/level_zero/context.hpp +++ b/source/adapters/level_zero/context.hpp @@ -217,6 +217,15 @@ struct ur_context_handle_t_ : _ur_object { // Add ur_event_handle_t to cache. void addEventToContextCache(ur_event_handle_t); + enum EventCacheType { + HostVisibleProfilingCacheType, + HostVisibleRegularCacheType, + HostInvisibleProfilingCacheType, + HostInvisibleRegularCacheType, + CounterBasedImmediateCacheType, + CounterBasedRegularCacheType + }; + enum ZeEventPoolCacheType { HostVisibleCacheType, HostInvisibleCacheType, @@ -226,14 +235,6 @@ struct ur_context_handle_t_ : _ur_object { HostInvisibleCounterBasedImmediateCacheType }; - enum EventCacheType { - HostVisibleProfilingCacheType, - HostVisibleRegularCacheType, - HostInvisibleProfilingCacheType, - HostInvisibleRegularCacheType, - CounterBasedImmediateCacheType, - CounterBasedRegularCacheType - }; std::list * getZeEventPoolCache(bool HostVisible, bool WithProfiling, From 6eb9eeddabae11b42fee50d5a5e2de94277d8ea6 Mon Sep 17 00:00:00 2001 From: Winston Zhang Date: Mon, 22 Jul 2024 17:54:02 -0700 Subject: [PATCH 26/36] [L0] Refactored against in-order list to enable CB event by default Signed-off-by: Winston Zhang --- source/adapters/level_zero/context.hpp | 17 ++++++++--------- 1 file changed, 8 insertions(+), 9 deletions(-) diff --git a/source/adapters/level_zero/context.hpp b/source/adapters/level_zero/context.hpp index b92c08d3a6..0b8f904cb3 100644 --- a/source/adapters/level_zero/context.hpp +++ b/source/adapters/level_zero/context.hpp @@ -217,15 +217,6 @@ struct ur_context_handle_t_ : _ur_object { // Add ur_event_handle_t to cache. void addEventToContextCache(ur_event_handle_t); - enum EventCacheType { - HostVisibleProfilingCacheType, - HostVisibleRegularCacheType, - HostInvisibleProfilingCacheType, - HostInvisibleRegularCacheType, - CounterBasedImmediateCacheType, - CounterBasedRegularCacheType - }; - enum ZeEventPoolCacheType { HostVisibleCacheType, HostInvisibleCacheType, @@ -235,6 +226,14 @@ struct ur_context_handle_t_ : _ur_object { HostInvisibleCounterBasedImmediateCacheType }; + enum EventCacheType { + HostVisibleProfilingCacheType, + HostVisibleRegularCacheType, + HostInvisibleProfilingCacheType, + HostInvisibleRegularCacheType, + CounterBasedImmediateCacheType, + CounterBasedRegularCacheType + }; std::list * getZeEventPoolCache(bool HostVisible, bool WithProfiling, From 9e4c7e31bff7ea03459f3be3197d02c99be679ad Mon Sep 17 00:00:00 2001 From: Winston Zhang Date: Tue, 6 Aug 2024 05:53:27 -0700 Subject: [PATCH 27/36] [L0] Test with llvm/sycl e2e Signed-off-by: Winston Zhang --- source/adapters/level_zero/context.hpp | 15 +++++++++------ 1 file changed, 9 insertions(+), 6 deletions(-) diff --git a/source/adapters/level_zero/context.hpp b/source/adapters/level_zero/context.hpp index 0b8f904cb3..b3cf95e832 100644 --- a/source/adapters/level_zero/context.hpp +++ b/source/adapters/level_zero/context.hpp @@ -147,9 +147,10 @@ struct ur_context_handle_t_ : _ur_object { // head. // // Cache of event pools to which host-visible events are added to. - std::vector> ZeEventPoolCache{12}; + std::vector> ZeEventPoolCache{ + ZeEventPoolCacheTypeCount * 2}; std::vector> - ZeEventPoolCacheDeviceMap{12}; + ZeEventPoolCacheDeviceMap{ZeEventPoolCacheTypeCount * 2}; // This map will be used to determine if a pool is full or not // by storing number of empty slots available in the pool. @@ -171,9 +172,9 @@ struct ur_context_handle_t_ : _ur_object { // Caches for events. using EventCache = std::vector>; - EventCache EventCaches{6}; + EventCache EventCaches{EventCacheTypeCount}; std::vector> - EventCachesDeviceMap{6}; + EventCachesDeviceMap{EventCacheTypeCount}; // Initialize the PI context. ur_result_t initialize(); @@ -223,7 +224,8 @@ struct ur_context_handle_t_ : _ur_object { HostVisibleCounterBasedRegularCacheType, HostInvisibleCounterBasedRegularCacheType, HostVisibleCounterBasedImmediateCacheType, - HostInvisibleCounterBasedImmediateCacheType + HostInvisibleCounterBasedImmediateCacheType, + ZeEventPoolCacheTypeCount }; enum EventCacheType { @@ -232,7 +234,8 @@ struct ur_context_handle_t_ : _ur_object { HostInvisibleProfilingCacheType, HostInvisibleRegularCacheType, CounterBasedImmediateCacheType, - CounterBasedRegularCacheType + CounterBasedRegularCacheType, + EventCacheTypeCount }; std::list * From 7a5dfbe0d8e6f00a7712042a8e8b2198031be6ab Mon Sep 17 00:00:00 2001 From: Winston Zhang Date: Fri, 23 Aug 2024 13:50:42 -0700 Subject: [PATCH 28/36] [L0] Fixed urQueueRelease from urEventReleaseInternal Signed-off-by: Winston Zhang --- source/adapters/level_zero/event.cpp | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/source/adapters/level_zero/event.cpp b/source/adapters/level_zero/event.cpp index 30dcce94db..ede10b37a6 100644 --- a/source/adapters/level_zero/event.cpp +++ b/source/adapters/level_zero/event.cpp @@ -833,11 +833,8 @@ urEventRetain(ur_event_handle_t Event ///< [in] handle of the event object ur_result_t urEventRelease(ur_event_handle_t Event ///< [in] handle of the event object ) { - if (--Event->RefCountExternal == 0 && Event->CounterBasedEventsEnabled) { - Event->Context->addEventToContextCache(Event); - } else { - UR_CALL(urEventReleaseInternal(Event)); - } + Event->RefCountExternal--; + UR_CALL(urEventReleaseInternal(Event)); return UR_RESULT_SUCCESS; } @@ -1057,7 +1054,8 @@ ur_result_t urEventReleaseInternal(ur_event_handle_t Event) { // When we add an event to the cache we need to check whether profiling is // enabled or not, so we access properties of the queue and that's why queue // must released later. - if (DisableEventsCaching || !Event->OwnNativeHandle) { + if ((Event->RefCountExternal > 0 && !Event->CounterBasedEventsEnabled) && + (DisableEventsCaching || !Event->OwnNativeHandle)) { delete Event; } else { Event->Context->addEventToContextCache(Event); From c1ea10629f12247a36b8718203b8a7666c94a0f5 Mon Sep 17 00:00:00 2001 From: Winston Zhang Date: Thu, 5 Sep 2024 10:40:27 -0700 Subject: [PATCH 29/36] [L0] Event cache segfault fixes Signed-off-by: Winston Zhang --- source/adapters/level_zero/context.cpp | 3 +-- source/adapters/level_zero/event.cpp | 3 +-- 2 files changed, 2 insertions(+), 4 deletions(-) diff --git a/source/adapters/level_zero/context.cpp b/source/adapters/level_zero/context.cpp index 197c54dc3f..2f6c4765ce 100644 --- a/source/adapters/level_zero/context.cpp +++ b/source/adapters/level_zero/context.cpp @@ -576,8 +576,7 @@ ur_event_handle_t ur_context_handle_t_::getEventFromContextCache( } Cache->erase(It); // We have to reset event before using it. - if (!CounterBasedEventEnabled) - Event->reset(); + Event->reset(); return Event; } diff --git a/source/adapters/level_zero/event.cpp b/source/adapters/level_zero/event.cpp index ede10b37a6..822bb3cdc5 100644 --- a/source/adapters/level_zero/event.cpp +++ b/source/adapters/level_zero/event.cpp @@ -1054,8 +1054,7 @@ ur_result_t urEventReleaseInternal(ur_event_handle_t Event) { // When we add an event to the cache we need to check whether profiling is // enabled or not, so we access properties of the queue and that's why queue // must released later. - if ((Event->RefCountExternal > 0 && !Event->CounterBasedEventsEnabled) && - (DisableEventsCaching || !Event->OwnNativeHandle)) { + if (DisableEventsCaching || !Event->OwnNativeHandle) { delete Event; } else { Event->Context->addEventToContextCache(Event); From 98f883db325d9c2d7e56c7ab22682731fa8fea8f Mon Sep 17 00:00:00 2001 From: Winston Zhang Date: Thu, 5 Sep 2024 12:25:55 -0700 Subject: [PATCH 30/36] [L0] Rebased Signed-off-by: Winston Zhang --- source/adapters/level_zero/context.cpp | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/source/adapters/level_zero/context.cpp b/source/adapters/level_zero/context.cpp index 2f6c4765ce..fee0b8015f 100644 --- a/source/adapters/level_zero/context.cpp +++ b/source/adapters/level_zero/context.cpp @@ -590,8 +590,7 @@ void ur_context_handle_t_::addEventToContextCache(ur_event_handle_t Event) { if (Event->CounterBasedEventsEnabled) { auto Cache = getCounterBasedEventCache( - !Legacy(Event->UrQueue) || Legacy(Event->UrQueue)->UsingImmCmdLists, - Device); + !(Event->UrQueue) || (Event->UrQueue)->UsingImmCmdLists, Device); Cache->emplace_back(Event); } else { auto Cache = getEventCache(Event->isHostVisible(), From 79fb832b94230c25d2a883773925342b73ae96c5 Mon Sep 17 00:00:00 2001 From: Winston Zhang Date: Thu, 5 Sep 2024 15:42:11 -0700 Subject: [PATCH 31/36] [L0] Fixed profiling fault in e2e Signed-off-by: Winston Zhang --- source/adapters/level_zero/context.cpp | 4 +++- source/adapters/level_zero/context.hpp | 20 +++++++++++++++----- 2 files changed, 18 insertions(+), 6 deletions(-) diff --git a/source/adapters/level_zero/context.cpp b/source/adapters/level_zero/context.cpp index fee0b8015f..59aa0d02d2 100644 --- a/source/adapters/level_zero/context.cpp +++ b/source/adapters/level_zero/context.cpp @@ -564,7 +564,7 @@ ur_event_handle_t ur_context_handle_t_::getEventFromContextCache( std::scoped_lock Lock(EventCacheMutex); auto Cache = getEventCache(HostVisible, WithProfiling, Device); if (CounterBasedEventEnabled) { - Cache = getCounterBasedEventCache(UsingImmCmdList, Device); + Cache = getCounterBasedEventCache(WithProfiling, UsingImmCmdList, Device); } if (Cache->empty()) return nullptr; @@ -576,6 +576,7 @@ ur_event_handle_t ur_context_handle_t_::getEventFromContextCache( } Cache->erase(It); // We have to reset event before using it. + // if(!CounterBasedEventEnabled) Event->reset(); return Event; } @@ -590,6 +591,7 @@ void ur_context_handle_t_::addEventToContextCache(ur_event_handle_t Event) { if (Event->CounterBasedEventsEnabled) { auto Cache = getCounterBasedEventCache( + Event->isProfilingEnabled(), !(Event->UrQueue) || (Event->UrQueue)->UsingImmCmdLists, Device); Cache->emplace_back(Event); } else { diff --git a/source/adapters/level_zero/context.hpp b/source/adapters/level_zero/context.hpp index b3cf95e832..1e35dfcc11 100644 --- a/source/adapters/level_zero/context.hpp +++ b/source/adapters/level_zero/context.hpp @@ -235,6 +235,8 @@ struct ur_context_handle_t_ : _ur_object { HostInvisibleRegularCacheType, CounterBasedImmediateCacheType, CounterBasedRegularCacheType, + CounterBasedImmediateProfilingCacheType, + CounterBasedRegularProfilingCacheType, EventCacheTypeCount }; @@ -359,12 +361,14 @@ struct ur_context_handle_t_ : _ur_object { } } }; - auto getCounterBasedEventCache(bool UsingImmediateCmdList, + auto getCounterBasedEventCache(bool WithProfiling, bool UsingImmediateCmdList, ur_device_handle_t Device) { if (UsingImmediateCmdList) { if (Device) { auto EventCachesMap = - &EventCachesDeviceMap[CounterBasedImmediateCacheType]; + WithProfiling + ? &EventCachesDeviceMap[CounterBasedImmediateProfilingCacheType] + : &EventCachesDeviceMap[CounterBasedImmediateCacheType]; if (EventCachesMap->find(Device) == EventCachesMap->end()) { EventCaches.emplace_back(); EventCachesMap->insert( @@ -372,12 +376,16 @@ struct ur_context_handle_t_ : _ur_object { } return &EventCaches[(*EventCachesMap)[Device]]; } else { - return &EventCaches[CounterBasedImmediateCacheType]; + return WithProfiling + ? &EventCaches[CounterBasedImmediateProfilingCacheType] + : &EventCaches[CounterBasedImmediateCacheType]; } } else { if (Device) { auto EventCachesMap = - &EventCachesDeviceMap[CounterBasedRegularCacheType]; + WithProfiling + ? &EventCachesDeviceMap[CounterBasedRegularProfilingCacheType] + : &EventCachesDeviceMap[CounterBasedRegularCacheType]; if (EventCachesMap->find(Device) == EventCachesMap->end()) { EventCaches.emplace_back(); EventCachesMap->insert( @@ -385,7 +393,9 @@ struct ur_context_handle_t_ : _ur_object { } return &EventCaches[(*EventCachesMap)[Device]]; } else { - return &EventCaches[CounterBasedRegularCacheType]; + return WithProfiling + ? &EventCaches[CounterBasedRegularProfilingCacheType] + : &EventCaches[CounterBasedRegularCacheType]; } } } From c0a24c3a89c4b39ba4679a7d124fa8ee2b84ba06 Mon Sep 17 00:00:00 2001 From: Winston Zhang Date: Wed, 11 Sep 2024 11:30:15 -0700 Subject: [PATCH 32/36] [L0] removed commented line Signed-off-by: Winston Zhang --- source/adapters/level_zero/context.cpp | 1 - 1 file changed, 1 deletion(-) diff --git a/source/adapters/level_zero/context.cpp b/source/adapters/level_zero/context.cpp index 59aa0d02d2..a989cea36d 100644 --- a/source/adapters/level_zero/context.cpp +++ b/source/adapters/level_zero/context.cpp @@ -576,7 +576,6 @@ ur_event_handle_t ur_context_handle_t_::getEventFromContextCache( } Cache->erase(It); // We have to reset event before using it. - // if(!CounterBasedEventEnabled) Event->reset(); return Event; } From ad1118285579afd66897133df96aea2ad9872ed2 Mon Sep 17 00:00:00 2001 From: Winston Zhang Date: Wed, 18 Sep 2024 10:47:04 -0700 Subject: [PATCH 33/36] [L0] Preallocate EventCachesDeviceMap on context creation Signed-off-by: Winston Zhang --- source/adapters/level_zero/context.hpp | 27 +++++++------------------- 1 file changed, 7 insertions(+), 20 deletions(-) diff --git a/source/adapters/level_zero/context.hpp b/source/adapters/level_zero/context.hpp index 1e35dfcc11..097b9e4b50 100644 --- a/source/adapters/level_zero/context.hpp +++ b/source/adapters/level_zero/context.hpp @@ -39,6 +39,13 @@ struct ur_context_handle_t_ : _ur_object { : ZeContext{ZeContext}, Devices{Devs, Devs + NumDevices}, NumDevices{NumDevices} { OwnNativeHandle = OwnZeContext; + for (const auto &Device : Devices) { + for (int i = 0; i < EventCacheTypeCount; i++) { + EventCaches.emplace_back(); + EventCachesDeviceMap[i].insert( + std::make_pair(Device, EventCaches.size() - 1)); + } + } } ur_context_handle_t_(ze_context_handle_t ZeContext) : ZeContext{ZeContext} {} @@ -333,11 +340,6 @@ struct ur_context_handle_t_ : _ur_object { auto EventCachesMap = WithProfiling ? &EventCachesDeviceMap[HostVisibleProfilingCacheType] : &EventCachesDeviceMap[HostVisibleRegularCacheType]; - if (EventCachesMap->find(Device) == EventCachesMap->end()) { - EventCaches.emplace_back(); - EventCachesMap->insert( - std::make_pair(Device, EventCaches.size() - 1)); - } return &EventCaches[(*EventCachesMap)[Device]]; } else { return WithProfiling ? &EventCaches[HostVisibleProfilingCacheType] @@ -349,11 +351,6 @@ struct ur_context_handle_t_ : _ur_object { WithProfiling ? &EventCachesDeviceMap[HostInvisibleProfilingCacheType] : &EventCachesDeviceMap[HostInvisibleRegularCacheType]; - if (EventCachesMap->find(Device) == EventCachesMap->end()) { - EventCaches.emplace_back(); - EventCachesMap->insert( - std::make_pair(Device, EventCaches.size() - 1)); - } return &EventCaches[(*EventCachesMap)[Device]]; } else { return WithProfiling ? &EventCaches[HostInvisibleProfilingCacheType] @@ -369,11 +366,6 @@ struct ur_context_handle_t_ : _ur_object { WithProfiling ? &EventCachesDeviceMap[CounterBasedImmediateProfilingCacheType] : &EventCachesDeviceMap[CounterBasedImmediateCacheType]; - if (EventCachesMap->find(Device) == EventCachesMap->end()) { - EventCaches.emplace_back(); - EventCachesMap->insert( - std::make_pair(Device, EventCaches.size() - 1)); - } return &EventCaches[(*EventCachesMap)[Device]]; } else { return WithProfiling @@ -386,11 +378,6 @@ struct ur_context_handle_t_ : _ur_object { WithProfiling ? &EventCachesDeviceMap[CounterBasedRegularProfilingCacheType] : &EventCachesDeviceMap[CounterBasedRegularCacheType]; - if (EventCachesMap->find(Device) == EventCachesMap->end()) { - EventCaches.emplace_back(); - EventCachesMap->insert( - std::make_pair(Device, EventCaches.size() - 1)); - } return &EventCaches[(*EventCachesMap)[Device]]; } else { return WithProfiling From 5653b307b2e1f440474da68cfebc46d26220dd5b Mon Sep 17 00:00:00 2001 From: Maosu Zhao Date: Thu, 19 Sep 2024 14:07:37 +0800 Subject: [PATCH 34/36] formatting --- source/loader/layers/sanitizer/asan_report.cpp | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/source/loader/layers/sanitizer/asan_report.cpp b/source/loader/layers/sanitizer/asan_report.cpp index db289e5e16..047ba905e0 100644 --- a/source/loader/layers/sanitizer/asan_report.cpp +++ b/source/loader/layers/sanitizer/asan_report.cpp @@ -83,8 +83,9 @@ void ReportMemoryLeak(const std::shared_ptr &AI) { getContext()->logger.always( "\n====ERROR: DeviceSanitizer: detected memory leaks of {}", ToString(AI->Type)); - getContext()->logger.always("Direct leak of {} byte(s) at {} allocated from:", - AI->UserEnd - AI->UserBegin, (void *)AI->UserBegin); + getContext()->logger.always( + "Direct leak of {} byte(s) at {} allocated from:", + AI->UserEnd - AI->UserBegin, (void *)AI->UserBegin); AI->AllocStack.print(); } From bb93a8f183b5fac5f816a6ec24fc7a53832588a9 Mon Sep 17 00:00:00 2001 From: Winston Zhang Date: Thu, 19 Sep 2024 10:51:00 -0700 Subject: [PATCH 35/36] [L0] Fix urEnqueueDeviceGlobalVariableRead to use device specific modules Follow up to https://github.com/oneapi-src/unified-runtime/pull/2096 to update urEnqueueDeviceGlobalVariableRead as well. Signed-off-by: Winston Zhang --- source/adapters/level_zero/kernel.cpp | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/source/adapters/level_zero/kernel.cpp b/source/adapters/level_zero/kernel.cpp index 9c638d53f6..1af2cc75f6 100644 --- a/source/adapters/level_zero/kernel.cpp +++ b/source/adapters/level_zero/kernel.cpp @@ -556,11 +556,19 @@ ur_result_t urEnqueueDeviceGlobalVariableRead( ) { std::scoped_lock lock(Queue->Mutex); + ze_module_handle_t ZeModule{}; + auto It = Program->ZeModuleMap.find(Queue->Device->ZeDevice); + if (It != Program->ZeModuleMap.end()) { + ZeModule = It->second; + } else { + ZeModule = Program->ZeModule; + } + // Find global variable pointer size_t GlobalVarSize = 0; void *GlobalVarPtr = nullptr; ZE2UR_CALL(zeModuleGetGlobalPointer, - (Program->ZeModule, Name, &GlobalVarSize, &GlobalVarPtr)); + (ZeModule, Name, &GlobalVarSize, &GlobalVarPtr)); if (GlobalVarSize < Offset + Count) { setErrorMessage("Read from device global variable is out of range.", UR_RESULT_ERROR_INVALID_VALUE, From a32549b4d173765e4476dda62ae627b3792e4e9e Mon Sep 17 00:00:00 2001 From: Piotr Balcer Date: Fri, 20 Sep 2024 12:15:15 +0200 Subject: [PATCH 36/36] fix perf regression in tracing layer In the current tracing layer, the parameters of the function being called are always printed to a string stream that may be used for logging. However, if logs are disabled, this just unnecessarily wastes times. --- scripts/templates/trcddi.cpp.mako | 12 +- source/common/logger/ur_logger_details.hpp | 2 + source/loader/layers/tracing/ur_trcddi.cpp | 2678 +++++++++++++------- 3 files changed, 1732 insertions(+), 960 deletions(-) diff --git a/scripts/templates/trcddi.cpp.mako b/scripts/templates/trcddi.cpp.mako index 671179d3e2..45a2baad76 100644 --- a/scripts/templates/trcddi.cpp.mako +++ b/scripts/templates/trcddi.cpp.mako @@ -45,15 +45,19 @@ namespace ur_tracing_layer ${th.make_pfncb_param_type(n, tags, obj)} params = { &${",&".join(th.make_param_lines(n, tags, obj, format=["name"]))} }; uint64_t instance = getContext()->notify_begin(${th.make_func_etor(n, tags, obj)}, "${th.make_func_name(n, tags, obj)}", ¶ms); - getContext()->logger.info("---> ${th.make_func_name(n, tags, obj)}"); + auto &logger = getContext()->logger; + + logger.info("---> ${th.make_func_name(n, tags, obj)}"); ${x}_result_t result = ${th.make_pfn_name(n, tags, obj)}( ${", ".join(th.make_param_lines(n, tags, obj, format=["name"]))} ); getContext()->notify_end(${th.make_func_etor(n, tags, obj)}, "${th.make_func_name(n, tags, obj)}", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, ${th.make_func_etor(n, tags, obj)}, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, ${th.make_func_etor(n, tags, obj)}, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } diff --git a/source/common/logger/ur_logger_details.hpp b/source/common/logger/ur_logger_details.hpp index f17d3b3f64..9c9462935e 100644 --- a/source/common/logger/ur_logger_details.hpp +++ b/source/common/logger/ur_logger_details.hpp @@ -30,6 +30,8 @@ class Logger { void setLevel(logger::Level level) { this->level = level; } + logger::Level getLevel() { return this->level; } + void setFlushLevel(logger::Level level) { if (sink) { this->sink->setFlushLevel(level); diff --git a/source/loader/layers/tracing/ur_trcddi.cpp b/source/loader/layers/tracing/ur_trcddi.cpp index 7f37c23417..c6e59174c9 100644 --- a/source/loader/layers/tracing/ur_trcddi.cpp +++ b/source/loader/layers/tracing/ur_trcddi.cpp @@ -40,16 +40,21 @@ __urdlllocal ur_result_t UR_APICALL urAdapterGet( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_ADAPTER_GET, "urAdapterGet", ¶ms); - getContext()->logger.info("---> urAdapterGet"); + auto &logger = getContext()->logger; + + logger.info("---> urAdapterGet"); ur_result_t result = pfnAdapterGet(NumEntries, phAdapters, pNumAdapters); getContext()->notify_end(UR_FUNCTION_ADAPTER_GET, "urAdapterGet", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_ADAPTER_GET, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_ADAPTER_GET, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -69,17 +74,21 @@ __urdlllocal ur_result_t UR_APICALL urAdapterRelease( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_ADAPTER_RELEASE, "urAdapterRelease", ¶ms); - getContext()->logger.info("---> urAdapterRelease"); + auto &logger = getContext()->logger; + + logger.info("---> urAdapterRelease"); ur_result_t result = pfnAdapterRelease(hAdapter); getContext()->notify_end(UR_FUNCTION_ADAPTER_RELEASE, "urAdapterRelease", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_ADAPTER_RELEASE, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_ADAPTER_RELEASE, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -99,17 +108,21 @@ __urdlllocal ur_result_t UR_APICALL urAdapterRetain( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_ADAPTER_RETAIN, "urAdapterRetain", ¶ms); - getContext()->logger.info("---> urAdapterRetain"); + auto &logger = getContext()->logger; + + logger.info("---> urAdapterRetain"); ur_result_t result = pfnAdapterRetain(hAdapter); getContext()->notify_end(UR_FUNCTION_ADAPTER_RETAIN, "urAdapterRetain", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_ADAPTER_RETAIN, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_ADAPTER_RETAIN, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -137,7 +150,9 @@ __urdlllocal ur_result_t UR_APICALL urAdapterGetLastError( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_ADAPTER_GET_LAST_ERROR, "urAdapterGetLastError", ¶ms); - getContext()->logger.info("---> urAdapterGetLastError"); + auto &logger = getContext()->logger; + + logger.info("---> urAdapterGetLastError"); ur_result_t result = pfnAdapterGetLastError(hAdapter, ppMessage, pError); @@ -145,10 +160,12 @@ __urdlllocal ur_result_t UR_APICALL urAdapterGetLastError( "urAdapterGetLastError", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ADAPTER_GET_LAST_ERROR, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_ADAPTER_GET_LAST_ERROR, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -179,7 +196,9 @@ __urdlllocal ur_result_t UR_APICALL urAdapterGetInfo( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_ADAPTER_GET_INFO, "urAdapterGetInfo", ¶ms); - getContext()->logger.info("---> urAdapterGetInfo"); + auto &logger = getContext()->logger; + + logger.info("---> urAdapterGetInfo"); ur_result_t result = pfnAdapterGetInfo(hAdapter, propName, propSize, pPropValue, pPropSizeRet); @@ -187,10 +206,12 @@ __urdlllocal ur_result_t UR_APICALL urAdapterGetInfo( getContext()->notify_end(UR_FUNCTION_ADAPTER_GET_INFO, "urAdapterGetInfo", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_ADAPTER_GET_INFO, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_ADAPTER_GET_INFO, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -224,7 +245,9 @@ __urdlllocal ur_result_t UR_APICALL urPlatformGet( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_PLATFORM_GET, "urPlatformGet", ¶ms); - getContext()->logger.info("---> urPlatformGet"); + auto &logger = getContext()->logger; + + logger.info("---> urPlatformGet"); ur_result_t result = pfnGet(phAdapters, NumAdapters, NumEntries, phPlatforms, pNumPlatforms); @@ -232,10 +255,12 @@ __urdlllocal ur_result_t UR_APICALL urPlatformGet( getContext()->notify_end(UR_FUNCTION_PLATFORM_GET, "urPlatformGet", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_PLATFORM_GET, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_PLATFORM_GET, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -266,7 +291,9 @@ __urdlllocal ur_result_t UR_APICALL urPlatformGetInfo( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_PLATFORM_GET_INFO, "urPlatformGetInfo", ¶ms); - getContext()->logger.info("---> urPlatformGetInfo"); + auto &logger = getContext()->logger; + + logger.info("---> urPlatformGetInfo"); ur_result_t result = pfnGetInfo(hPlatform, propName, propSize, pPropValue, pPropSizeRet); @@ -274,10 +301,12 @@ __urdlllocal ur_result_t UR_APICALL urPlatformGetInfo( getContext()->notify_end(UR_FUNCTION_PLATFORM_GET_INFO, "urPlatformGetInfo", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_PLATFORM_GET_INFO, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_PLATFORM_GET_INFO, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -299,7 +328,9 @@ __urdlllocal ur_result_t UR_APICALL urPlatformGetApiVersion( getContext()->notify_begin(UR_FUNCTION_PLATFORM_GET_API_VERSION, "urPlatformGetApiVersion", ¶ms); - getContext()->logger.info("---> urPlatformGetApiVersion"); + auto &logger = getContext()->logger; + + logger.info("---> urPlatformGetApiVersion"); ur_result_t result = pfnGetApiVersion(hPlatform, pVersion); @@ -307,10 +338,12 @@ __urdlllocal ur_result_t UR_APICALL urPlatformGetApiVersion( "urPlatformGetApiVersion", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_PLATFORM_GET_API_VERSION, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_PLATFORM_GET_API_VERSION, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -335,7 +368,9 @@ __urdlllocal ur_result_t UR_APICALL urPlatformGetNativeHandle( getContext()->notify_begin(UR_FUNCTION_PLATFORM_GET_NATIVE_HANDLE, "urPlatformGetNativeHandle", ¶ms); - getContext()->logger.info("---> urPlatformGetNativeHandle"); + auto &logger = getContext()->logger; + + logger.info("---> urPlatformGetNativeHandle"); ur_result_t result = pfnGetNativeHandle(hPlatform, phNativePlatform); @@ -343,10 +378,12 @@ __urdlllocal ur_result_t UR_APICALL urPlatformGetNativeHandle( "urPlatformGetNativeHandle", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_PLATFORM_GET_NATIVE_HANDLE, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_PLATFORM_GET_NATIVE_HANDLE, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -376,7 +413,9 @@ __urdlllocal ur_result_t UR_APICALL urPlatformCreateWithNativeHandle( UR_FUNCTION_PLATFORM_CREATE_WITH_NATIVE_HANDLE, "urPlatformCreateWithNativeHandle", ¶ms); - getContext()->logger.info("---> urPlatformCreateWithNativeHandle"); + auto &logger = getContext()->logger; + + logger.info("---> urPlatformCreateWithNativeHandle"); ur_result_t result = pfnCreateWithNativeHandle(hNativePlatform, hAdapter, pProperties, phPlatform); @@ -385,10 +424,12 @@ __urdlllocal ur_result_t UR_APICALL urPlatformCreateWithNativeHandle( "urPlatformCreateWithNativeHandle", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_PLATFORM_CREATE_WITH_NATIVE_HANDLE, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_PLATFORM_CREATE_WITH_NATIVE_HANDLE, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -416,7 +457,9 @@ __urdlllocal ur_result_t UR_APICALL urPlatformGetBackendOption( getContext()->notify_begin(UR_FUNCTION_PLATFORM_GET_BACKEND_OPTION, "urPlatformGetBackendOption", ¶ms); - getContext()->logger.info("---> urPlatformGetBackendOption"); + auto &logger = getContext()->logger; + + logger.info("---> urPlatformGetBackendOption"); ur_result_t result = pfnGetBackendOption(hPlatform, pFrontendOption, ppPlatformOption); @@ -425,10 +468,12 @@ __urdlllocal ur_result_t UR_APICALL urPlatformGetBackendOption( "urPlatformGetBackendOption", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_PLATFORM_GET_BACKEND_OPTION, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_PLATFORM_GET_BACKEND_OPTION, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -461,7 +506,9 @@ __urdlllocal ur_result_t UR_APICALL urDeviceGet( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_DEVICE_GET, "urDeviceGet", ¶ms); - getContext()->logger.info("---> urDeviceGet"); + auto &logger = getContext()->logger; + + logger.info("---> urDeviceGet"); ur_result_t result = pfnGet(hPlatform, DeviceType, NumEntries, phDevices, pNumDevices); @@ -469,9 +516,12 @@ __urdlllocal ur_result_t UR_APICALL urDeviceGet( getContext()->notify_end(UR_FUNCTION_DEVICE_GET, "urDeviceGet", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_DEVICE_GET, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_DEVICE_GET, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -503,7 +553,9 @@ __urdlllocal ur_result_t UR_APICALL urDeviceGetInfo( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_DEVICE_GET_INFO, "urDeviceGetInfo", ¶ms); - getContext()->logger.info("---> urDeviceGetInfo"); + auto &logger = getContext()->logger; + + logger.info("---> urDeviceGetInfo"); ur_result_t result = pfnGetInfo(hDevice, propName, propSize, pPropValue, pPropSizeRet); @@ -511,10 +563,12 @@ __urdlllocal ur_result_t UR_APICALL urDeviceGetInfo( getContext()->notify_end(UR_FUNCTION_DEVICE_GET_INFO, "urDeviceGetInfo", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_DEVICE_GET_INFO, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_DEVICE_GET_INFO, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -535,17 +589,21 @@ __urdlllocal ur_result_t UR_APICALL urDeviceRetain( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_DEVICE_RETAIN, "urDeviceRetain", ¶ms); - getContext()->logger.info("---> urDeviceRetain"); + auto &logger = getContext()->logger; + + logger.info("---> urDeviceRetain"); ur_result_t result = pfnRetain(hDevice); getContext()->notify_end(UR_FUNCTION_DEVICE_RETAIN, "urDeviceRetain", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_DEVICE_RETAIN, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_DEVICE_RETAIN, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -566,17 +624,21 @@ __urdlllocal ur_result_t UR_APICALL urDeviceRelease( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_DEVICE_RELEASE, "urDeviceRelease", ¶ms); - getContext()->logger.info("---> urDeviceRelease"); + auto &logger = getContext()->logger; + + logger.info("---> urDeviceRelease"); ur_result_t result = pfnRelease(hDevice); getContext()->notify_end(UR_FUNCTION_DEVICE_RELEASE, "urDeviceRelease", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_DEVICE_RELEASE, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_DEVICE_RELEASE, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -607,7 +669,9 @@ __urdlllocal ur_result_t UR_APICALL urDevicePartition( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_DEVICE_PARTITION, "urDevicePartition", ¶ms); - getContext()->logger.info("---> urDevicePartition"); + auto &logger = getContext()->logger; + + logger.info("---> urDevicePartition"); ur_result_t result = pfnPartition(hDevice, pProperties, NumDevices, phSubDevices, pNumDevicesRet); @@ -615,10 +679,12 @@ __urdlllocal ur_result_t UR_APICALL urDevicePartition( getContext()->notify_end(UR_FUNCTION_DEVICE_PARTITION, "urDevicePartition", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_DEVICE_PARTITION, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_DEVICE_PARTITION, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -648,7 +714,9 @@ __urdlllocal ur_result_t UR_APICALL urDeviceSelectBinary( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_DEVICE_SELECT_BINARY, "urDeviceSelectBinary", ¶ms); - getContext()->logger.info("---> urDeviceSelectBinary"); + auto &logger = getContext()->logger; + + logger.info("---> urDeviceSelectBinary"); ur_result_t result = pfnSelectBinary(hDevice, pBinaries, NumBinaries, pSelectedBinary); @@ -657,10 +725,12 @@ __urdlllocal ur_result_t UR_APICALL urDeviceSelectBinary( "urDeviceSelectBinary", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_DEVICE_SELECT_BINARY, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_DEVICE_SELECT_BINARY, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -684,7 +754,9 @@ __urdlllocal ur_result_t UR_APICALL urDeviceGetNativeHandle( getContext()->notify_begin(UR_FUNCTION_DEVICE_GET_NATIVE_HANDLE, "urDeviceGetNativeHandle", ¶ms); - getContext()->logger.info("---> urDeviceGetNativeHandle"); + auto &logger = getContext()->logger; + + logger.info("---> urDeviceGetNativeHandle"); ur_result_t result = pfnGetNativeHandle(hDevice, phNativeDevice); @@ -692,10 +764,12 @@ __urdlllocal ur_result_t UR_APICALL urDeviceGetNativeHandle( "urDeviceGetNativeHandle", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_DEVICE_GET_NATIVE_HANDLE, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_DEVICE_GET_NATIVE_HANDLE, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -725,7 +799,9 @@ __urdlllocal ur_result_t UR_APICALL urDeviceCreateWithNativeHandle( getContext()->notify_begin(UR_FUNCTION_DEVICE_CREATE_WITH_NATIVE_HANDLE, "urDeviceCreateWithNativeHandle", ¶ms); - getContext()->logger.info("---> urDeviceCreateWithNativeHandle"); + auto &logger = getContext()->logger; + + logger.info("---> urDeviceCreateWithNativeHandle"); ur_result_t result = pfnCreateWithNativeHandle(hNativeDevice, hAdapter, pProperties, phDevice); @@ -734,10 +810,12 @@ __urdlllocal ur_result_t UR_APICALL urDeviceCreateWithNativeHandle( "urDeviceCreateWithNativeHandle", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_DEVICE_CREATE_WITH_NATIVE_HANDLE, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_DEVICE_CREATE_WITH_NATIVE_HANDLE, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -766,7 +844,9 @@ __urdlllocal ur_result_t UR_APICALL urDeviceGetGlobalTimestamps( getContext()->notify_begin(UR_FUNCTION_DEVICE_GET_GLOBAL_TIMESTAMPS, "urDeviceGetGlobalTimestamps", ¶ms); - getContext()->logger.info("---> urDeviceGetGlobalTimestamps"); + auto &logger = getContext()->logger; + + logger.info("---> urDeviceGetGlobalTimestamps"); ur_result_t result = pfnGetGlobalTimestamps(hDevice, pDeviceTimestamp, pHostTimestamp); @@ -775,10 +855,12 @@ __urdlllocal ur_result_t UR_APICALL urDeviceGetGlobalTimestamps( "urDeviceGetGlobalTimestamps", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_DEVICE_GET_GLOBAL_TIMESTAMPS, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_DEVICE_GET_GLOBAL_TIMESTAMPS, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -805,7 +887,9 @@ __urdlllocal ur_result_t UR_APICALL urContextCreate( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_CONTEXT_CREATE, "urContextCreate", ¶ms); - getContext()->logger.info("---> urContextCreate"); + auto &logger = getContext()->logger; + + logger.info("---> urContextCreate"); ur_result_t result = pfnCreate(DeviceCount, phDevices, pProperties, phContext); @@ -813,10 +897,12 @@ __urdlllocal ur_result_t UR_APICALL urContextCreate( getContext()->notify_end(UR_FUNCTION_CONTEXT_CREATE, "urContextCreate", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_CONTEXT_CREATE, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_CONTEXT_CREATE, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -837,17 +923,21 @@ __urdlllocal ur_result_t UR_APICALL urContextRetain( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_CONTEXT_RETAIN, "urContextRetain", ¶ms); - getContext()->logger.info("---> urContextRetain"); + auto &logger = getContext()->logger; + + logger.info("---> urContextRetain"); ur_result_t result = pfnRetain(hContext); getContext()->notify_end(UR_FUNCTION_CONTEXT_RETAIN, "urContextRetain", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_CONTEXT_RETAIN, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_CONTEXT_RETAIN, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -868,17 +958,21 @@ __urdlllocal ur_result_t UR_APICALL urContextRelease( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_CONTEXT_RELEASE, "urContextRelease", ¶ms); - getContext()->logger.info("---> urContextRelease"); + auto &logger = getContext()->logger; + + logger.info("---> urContextRelease"); ur_result_t result = pfnRelease(hContext); getContext()->notify_end(UR_FUNCTION_CONTEXT_RELEASE, "urContextRelease", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_CONTEXT_RELEASE, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_CONTEXT_RELEASE, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -911,7 +1005,9 @@ __urdlllocal ur_result_t UR_APICALL urContextGetInfo( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_CONTEXT_GET_INFO, "urContextGetInfo", ¶ms); - getContext()->logger.info("---> urContextGetInfo"); + auto &logger = getContext()->logger; + + logger.info("---> urContextGetInfo"); ur_result_t result = pfnGetInfo(hContext, propName, propSize, pPropValue, pPropSizeRet); @@ -919,10 +1015,12 @@ __urdlllocal ur_result_t UR_APICALL urContextGetInfo( getContext()->notify_end(UR_FUNCTION_CONTEXT_GET_INFO, "urContextGetInfo", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_CONTEXT_GET_INFO, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_CONTEXT_GET_INFO, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -947,7 +1045,9 @@ __urdlllocal ur_result_t UR_APICALL urContextGetNativeHandle( getContext()->notify_begin(UR_FUNCTION_CONTEXT_GET_NATIVE_HANDLE, "urContextGetNativeHandle", ¶ms); - getContext()->logger.info("---> urContextGetNativeHandle"); + auto &logger = getContext()->logger; + + logger.info("---> urContextGetNativeHandle"); ur_result_t result = pfnGetNativeHandle(hContext, phNativeContext); @@ -955,10 +1055,12 @@ __urdlllocal ur_result_t UR_APICALL urContextGetNativeHandle( "urContextGetNativeHandle", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_CONTEXT_GET_NATIVE_HANDLE, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_CONTEXT_GET_NATIVE_HANDLE, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -993,7 +1095,9 @@ __urdlllocal ur_result_t UR_APICALL urContextCreateWithNativeHandle( UR_FUNCTION_CONTEXT_CREATE_WITH_NATIVE_HANDLE, "urContextCreateWithNativeHandle", ¶ms); - getContext()->logger.info("---> urContextCreateWithNativeHandle"); + auto &logger = getContext()->logger; + + logger.info("---> urContextCreateWithNativeHandle"); ur_result_t result = pfnCreateWithNativeHandle(hNativeContext, hAdapter, numDevices, @@ -1003,10 +1107,12 @@ __urdlllocal ur_result_t UR_APICALL urContextCreateWithNativeHandle( "urContextCreateWithNativeHandle", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_CONTEXT_CREATE_WITH_NATIVE_HANDLE, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_CONTEXT_CREATE_WITH_NATIVE_HANDLE, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -1033,7 +1139,9 @@ __urdlllocal ur_result_t UR_APICALL urContextSetExtendedDeleter( getContext()->notify_begin(UR_FUNCTION_CONTEXT_SET_EXTENDED_DELETER, "urContextSetExtendedDeleter", ¶ms); - getContext()->logger.info("---> urContextSetExtendedDeleter"); + auto &logger = getContext()->logger; + + logger.info("---> urContextSetExtendedDeleter"); ur_result_t result = pfnSetExtendedDeleter(hContext, pfnDeleter, pUserData); @@ -1041,10 +1149,12 @@ __urdlllocal ur_result_t UR_APICALL urContextSetExtendedDeleter( "urContextSetExtendedDeleter", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_CONTEXT_SET_EXTENDED_DELETER, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_CONTEXT_SET_EXTENDED_DELETER, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -1071,7 +1181,9 @@ __urdlllocal ur_result_t UR_APICALL urMemImageCreate( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_MEM_IMAGE_CREATE, "urMemImageCreate", ¶ms); - getContext()->logger.info("---> urMemImageCreate"); + auto &logger = getContext()->logger; + + logger.info("---> urMemImageCreate"); ur_result_t result = pfnImageCreate(hContext, flags, pImageFormat, pImageDesc, pHost, phMem); @@ -1079,10 +1191,12 @@ __urdlllocal ur_result_t UR_APICALL urMemImageCreate( getContext()->notify_end(UR_FUNCTION_MEM_IMAGE_CREATE, "urMemImageCreate", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_MEM_IMAGE_CREATE, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_MEM_IMAGE_CREATE, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -1109,7 +1223,9 @@ __urdlllocal ur_result_t UR_APICALL urMemBufferCreate( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_MEM_BUFFER_CREATE, "urMemBufferCreate", ¶ms); - getContext()->logger.info("---> urMemBufferCreate"); + auto &logger = getContext()->logger; + + logger.info("---> urMemBufferCreate"); ur_result_t result = pfnBufferCreate(hContext, flags, size, pProperties, phBuffer); @@ -1117,10 +1233,12 @@ __urdlllocal ur_result_t UR_APICALL urMemBufferCreate( getContext()->notify_end(UR_FUNCTION_MEM_BUFFER_CREATE, "urMemBufferCreate", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_MEM_BUFFER_CREATE, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_MEM_BUFFER_CREATE, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -1141,16 +1259,21 @@ __urdlllocal ur_result_t UR_APICALL urMemRetain( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_MEM_RETAIN, "urMemRetain", ¶ms); - getContext()->logger.info("---> urMemRetain"); + auto &logger = getContext()->logger; + + logger.info("---> urMemRetain"); ur_result_t result = pfnRetain(hMem); getContext()->notify_end(UR_FUNCTION_MEM_RETAIN, "urMemRetain", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_MEM_RETAIN, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_MEM_RETAIN, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -1171,16 +1294,21 @@ __urdlllocal ur_result_t UR_APICALL urMemRelease( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_MEM_RELEASE, "urMemRelease", ¶ms); - getContext()->logger.info("---> urMemRelease"); + auto &logger = getContext()->logger; + + logger.info("---> urMemRelease"); ur_result_t result = pfnRelease(hMem); getContext()->notify_end(UR_FUNCTION_MEM_RELEASE, "urMemRelease", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_MEM_RELEASE, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_MEM_RELEASE, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -1208,7 +1336,9 @@ __urdlllocal ur_result_t UR_APICALL urMemBufferPartition( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_MEM_BUFFER_PARTITION, "urMemBufferPartition", ¶ms); - getContext()->logger.info("---> urMemBufferPartition"); + auto &logger = getContext()->logger; + + logger.info("---> urMemBufferPartition"); ur_result_t result = pfnBufferPartition(hBuffer, flags, bufferCreateType, pRegion, phMem); @@ -1217,10 +1347,12 @@ __urdlllocal ur_result_t UR_APICALL urMemBufferPartition( "urMemBufferPartition", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_MEM_BUFFER_PARTITION, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_MEM_BUFFER_PARTITION, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -1245,7 +1377,9 @@ __urdlllocal ur_result_t UR_APICALL urMemGetNativeHandle( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_MEM_GET_NATIVE_HANDLE, "urMemGetNativeHandle", ¶ms); - getContext()->logger.info("---> urMemGetNativeHandle"); + auto &logger = getContext()->logger; + + logger.info("---> urMemGetNativeHandle"); ur_result_t result = pfnGetNativeHandle(hMem, hDevice, phNativeMem); @@ -1253,10 +1387,12 @@ __urdlllocal ur_result_t UR_APICALL urMemGetNativeHandle( "urMemGetNativeHandle", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_MEM_GET_NATIVE_HANDLE, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_MEM_GET_NATIVE_HANDLE, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -1285,7 +1421,9 @@ __urdlllocal ur_result_t UR_APICALL urMemBufferCreateWithNativeHandle( UR_FUNCTION_MEM_BUFFER_CREATE_WITH_NATIVE_HANDLE, "urMemBufferCreateWithNativeHandle", ¶ms); - getContext()->logger.info("---> urMemBufferCreateWithNativeHandle"); + auto &logger = getContext()->logger; + + logger.info("---> urMemBufferCreateWithNativeHandle"); ur_result_t result = pfnBufferCreateWithNativeHandle(hNativeMem, hContext, pProperties, phMem); @@ -1294,10 +1432,13 @@ __urdlllocal ur_result_t UR_APICALL urMemBufferCreateWithNativeHandle( "urMemBufferCreateWithNativeHandle", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_MEM_BUFFER_CREATE_WITH_NATIVE_HANDLE, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_MEM_BUFFER_CREATE_WITH_NATIVE_HANDLE, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -1330,7 +1471,9 @@ __urdlllocal ur_result_t UR_APICALL urMemImageCreateWithNativeHandle( UR_FUNCTION_MEM_IMAGE_CREATE_WITH_NATIVE_HANDLE, "urMemImageCreateWithNativeHandle", ¶ms); - getContext()->logger.info("---> urMemImageCreateWithNativeHandle"); + auto &logger = getContext()->logger; + + logger.info("---> urMemImageCreateWithNativeHandle"); ur_result_t result = pfnImageCreateWithNativeHandle( hNativeMem, hContext, pImageFormat, pImageDesc, pProperties, phMem); @@ -1339,10 +1482,12 @@ __urdlllocal ur_result_t UR_APICALL urMemImageCreateWithNativeHandle( "urMemImageCreateWithNativeHandle", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_MEM_IMAGE_CREATE_WITH_NATIVE_HANDLE, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_MEM_IMAGE_CREATE_WITH_NATIVE_HANDLE, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -1375,7 +1520,9 @@ __urdlllocal ur_result_t UR_APICALL urMemGetInfo( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_MEM_GET_INFO, "urMemGetInfo", ¶ms); - getContext()->logger.info("---> urMemGetInfo"); + auto &logger = getContext()->logger; + + logger.info("---> urMemGetInfo"); ur_result_t result = pfnGetInfo(hMemory, propName, propSize, pPropValue, pPropSizeRet); @@ -1383,10 +1530,12 @@ __urdlllocal ur_result_t UR_APICALL urMemGetInfo( getContext()->notify_end(UR_FUNCTION_MEM_GET_INFO, "urMemGetInfo", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_MEM_GET_INFO, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_MEM_GET_INFO, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -1418,7 +1567,9 @@ __urdlllocal ur_result_t UR_APICALL urMemImageGetInfo( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_MEM_IMAGE_GET_INFO, "urMemImageGetInfo", ¶ms); - getContext()->logger.info("---> urMemImageGetInfo"); + auto &logger = getContext()->logger; + + logger.info("---> urMemImageGetInfo"); ur_result_t result = pfnImageGetInfo(hMemory, propName, propSize, pPropValue, pPropSizeRet); @@ -1426,10 +1577,12 @@ __urdlllocal ur_result_t UR_APICALL urMemImageGetInfo( getContext()->notify_end(UR_FUNCTION_MEM_IMAGE_GET_INFO, "urMemImageGetInfo", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_MEM_IMAGE_GET_INFO, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_MEM_IMAGE_GET_INFO, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -1452,17 +1605,21 @@ __urdlllocal ur_result_t UR_APICALL urSamplerCreate( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_SAMPLER_CREATE, "urSamplerCreate", ¶ms); - getContext()->logger.info("---> urSamplerCreate"); + auto &logger = getContext()->logger; + + logger.info("---> urSamplerCreate"); ur_result_t result = pfnCreate(hContext, pDesc, phSampler); getContext()->notify_end(UR_FUNCTION_SAMPLER_CREATE, "urSamplerCreate", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_SAMPLER_CREATE, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_SAMPLER_CREATE, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -1483,17 +1640,21 @@ __urdlllocal ur_result_t UR_APICALL urSamplerRetain( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_SAMPLER_RETAIN, "urSamplerRetain", ¶ms); - getContext()->logger.info("---> urSamplerRetain"); + auto &logger = getContext()->logger; + + logger.info("---> urSamplerRetain"); ur_result_t result = pfnRetain(hSampler); getContext()->notify_end(UR_FUNCTION_SAMPLER_RETAIN, "urSamplerRetain", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_SAMPLER_RETAIN, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_SAMPLER_RETAIN, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -1514,17 +1675,21 @@ __urdlllocal ur_result_t UR_APICALL urSamplerRelease( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_SAMPLER_RELEASE, "urSamplerRelease", ¶ms); - getContext()->logger.info("---> urSamplerRelease"); + auto &logger = getContext()->logger; + + logger.info("---> urSamplerRelease"); ur_result_t result = pfnRelease(hSampler); getContext()->notify_end(UR_FUNCTION_SAMPLER_RELEASE, "urSamplerRelease", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_SAMPLER_RELEASE, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_SAMPLER_RELEASE, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -1553,7 +1718,9 @@ __urdlllocal ur_result_t UR_APICALL urSamplerGetInfo( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_SAMPLER_GET_INFO, "urSamplerGetInfo", ¶ms); - getContext()->logger.info("---> urSamplerGetInfo"); + auto &logger = getContext()->logger; + + logger.info("---> urSamplerGetInfo"); ur_result_t result = pfnGetInfo(hSampler, propName, propSize, pPropValue, pPropSizeRet); @@ -1561,10 +1728,12 @@ __urdlllocal ur_result_t UR_APICALL urSamplerGetInfo( getContext()->notify_end(UR_FUNCTION_SAMPLER_GET_INFO, "urSamplerGetInfo", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_SAMPLER_GET_INFO, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_SAMPLER_GET_INFO, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -1589,7 +1758,9 @@ __urdlllocal ur_result_t UR_APICALL urSamplerGetNativeHandle( getContext()->notify_begin(UR_FUNCTION_SAMPLER_GET_NATIVE_HANDLE, "urSamplerGetNativeHandle", ¶ms); - getContext()->logger.info("---> urSamplerGetNativeHandle"); + auto &logger = getContext()->logger; + + logger.info("---> urSamplerGetNativeHandle"); ur_result_t result = pfnGetNativeHandle(hSampler, phNativeSampler); @@ -1597,10 +1768,12 @@ __urdlllocal ur_result_t UR_APICALL urSamplerGetNativeHandle( "urSamplerGetNativeHandle", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_SAMPLER_GET_NATIVE_HANDLE, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_SAMPLER_GET_NATIVE_HANDLE, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -1629,7 +1802,9 @@ __urdlllocal ur_result_t UR_APICALL urSamplerCreateWithNativeHandle( UR_FUNCTION_SAMPLER_CREATE_WITH_NATIVE_HANDLE, "urSamplerCreateWithNativeHandle", ¶ms); - getContext()->logger.info("---> urSamplerCreateWithNativeHandle"); + auto &logger = getContext()->logger; + + logger.info("---> urSamplerCreateWithNativeHandle"); ur_result_t result = pfnCreateWithNativeHandle(hNativeSampler, hContext, pProperties, phSampler); @@ -1638,10 +1813,12 @@ __urdlllocal ur_result_t UR_APICALL urSamplerCreateWithNativeHandle( "urSamplerCreateWithNativeHandle", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_SAMPLER_CREATE_WITH_NATIVE_HANDLE, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_SAMPLER_CREATE_WITH_NATIVE_HANDLE, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -1669,17 +1846,21 @@ __urdlllocal ur_result_t UR_APICALL urUSMHostAlloc( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_USM_HOST_ALLOC, "urUSMHostAlloc", ¶ms); - getContext()->logger.info("---> urUSMHostAlloc"); + auto &logger = getContext()->logger; + + logger.info("---> urUSMHostAlloc"); ur_result_t result = pfnHostAlloc(hContext, pUSMDesc, pool, size, ppMem); getContext()->notify_end(UR_FUNCTION_USM_HOST_ALLOC, "urUSMHostAlloc", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_USM_HOST_ALLOC, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_USM_HOST_ALLOC, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -1708,7 +1889,9 @@ __urdlllocal ur_result_t UR_APICALL urUSMDeviceAlloc( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_USM_DEVICE_ALLOC, "urUSMDeviceAlloc", ¶ms); - getContext()->logger.info("---> urUSMDeviceAlloc"); + auto &logger = getContext()->logger; + + logger.info("---> urUSMDeviceAlloc"); ur_result_t result = pfnDeviceAlloc(hContext, hDevice, pUSMDesc, pool, size, ppMem); @@ -1716,10 +1899,12 @@ __urdlllocal ur_result_t UR_APICALL urUSMDeviceAlloc( getContext()->notify_end(UR_FUNCTION_USM_DEVICE_ALLOC, "urUSMDeviceAlloc", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_USM_DEVICE_ALLOC, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_USM_DEVICE_ALLOC, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -1748,7 +1933,9 @@ __urdlllocal ur_result_t UR_APICALL urUSMSharedAlloc( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_USM_SHARED_ALLOC, "urUSMSharedAlloc", ¶ms); - getContext()->logger.info("---> urUSMSharedAlloc"); + auto &logger = getContext()->logger; + + logger.info("---> urUSMSharedAlloc"); ur_result_t result = pfnSharedAlloc(hContext, hDevice, pUSMDesc, pool, size, ppMem); @@ -1756,10 +1943,12 @@ __urdlllocal ur_result_t UR_APICALL urUSMSharedAlloc( getContext()->notify_end(UR_FUNCTION_USM_SHARED_ALLOC, "urUSMSharedAlloc", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_USM_SHARED_ALLOC, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_USM_SHARED_ALLOC, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -1780,16 +1969,21 @@ __urdlllocal ur_result_t UR_APICALL urUSMFree( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_USM_FREE, "urUSMFree", ¶ms); - getContext()->logger.info("---> urUSMFree"); + auto &logger = getContext()->logger; + + logger.info("---> urUSMFree"); ur_result_t result = pfnFree(hContext, pMem); getContext()->notify_end(UR_FUNCTION_USM_FREE, "urUSMFree", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_USM_FREE, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_USM_FREE, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -1820,7 +2014,9 @@ __urdlllocal ur_result_t UR_APICALL urUSMGetMemAllocInfo( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_USM_GET_MEM_ALLOC_INFO, "urUSMGetMemAllocInfo", ¶ms); - getContext()->logger.info("---> urUSMGetMemAllocInfo"); + auto &logger = getContext()->logger; + + logger.info("---> urUSMGetMemAllocInfo"); ur_result_t result = pfnGetMemAllocInfo(hContext, pMem, propName, propSize, pPropValue, pPropSizeRet); @@ -1829,10 +2025,12 @@ __urdlllocal ur_result_t UR_APICALL urUSMGetMemAllocInfo( "urUSMGetMemAllocInfo", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_USM_GET_MEM_ALLOC_INFO, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_USM_GET_MEM_ALLOC_INFO, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -1856,17 +2054,21 @@ __urdlllocal ur_result_t UR_APICALL urUSMPoolCreate( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_USM_POOL_CREATE, "urUSMPoolCreate", ¶ms); - getContext()->logger.info("---> urUSMPoolCreate"); + auto &logger = getContext()->logger; + + logger.info("---> urUSMPoolCreate"); ur_result_t result = pfnPoolCreate(hContext, pPoolDesc, ppPool); getContext()->notify_end(UR_FUNCTION_USM_POOL_CREATE, "urUSMPoolCreate", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_USM_POOL_CREATE, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_USM_POOL_CREATE, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -1886,17 +2088,21 @@ __urdlllocal ur_result_t UR_APICALL urUSMPoolRetain( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_USM_POOL_RETAIN, "urUSMPoolRetain", ¶ms); - getContext()->logger.info("---> urUSMPoolRetain"); + auto &logger = getContext()->logger; + + logger.info("---> urUSMPoolRetain"); ur_result_t result = pfnPoolRetain(pPool); getContext()->notify_end(UR_FUNCTION_USM_POOL_RETAIN, "urUSMPoolRetain", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_USM_POOL_RETAIN, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_USM_POOL_RETAIN, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -1916,17 +2122,21 @@ __urdlllocal ur_result_t UR_APICALL urUSMPoolRelease( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_USM_POOL_RELEASE, "urUSMPoolRelease", ¶ms); - getContext()->logger.info("---> urUSMPoolRelease"); + auto &logger = getContext()->logger; + + logger.info("---> urUSMPoolRelease"); ur_result_t result = pfnPoolRelease(pPool); getContext()->notify_end(UR_FUNCTION_USM_POOL_RELEASE, "urUSMPoolRelease", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_USM_POOL_RELEASE, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_USM_POOL_RELEASE, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -1954,7 +2164,9 @@ __urdlllocal ur_result_t UR_APICALL urUSMPoolGetInfo( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_USM_POOL_GET_INFO, "urUSMPoolGetInfo", ¶ms); - getContext()->logger.info("---> urUSMPoolGetInfo"); + auto &logger = getContext()->logger; + + logger.info("---> urUSMPoolGetInfo"); ur_result_t result = pfnPoolGetInfo(hPool, propName, propSize, pPropValue, pPropSizeRet); @@ -1962,10 +2174,12 @@ __urdlllocal ur_result_t UR_APICALL urUSMPoolGetInfo( getContext()->notify_end(UR_FUNCTION_USM_POOL_GET_INFO, "urUSMPoolGetInfo", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_USM_POOL_GET_INFO, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_USM_POOL_GET_INFO, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -2002,7 +2216,9 @@ __urdlllocal ur_result_t UR_APICALL urVirtualMemGranularityGetInfo( getContext()->notify_begin(UR_FUNCTION_VIRTUAL_MEM_GRANULARITY_GET_INFO, "urVirtualMemGranularityGetInfo", ¶ms); - getContext()->logger.info("---> urVirtualMemGranularityGetInfo"); + auto &logger = getContext()->logger; + + logger.info("---> urVirtualMemGranularityGetInfo"); ur_result_t result = pfnGranularityGetInfo( hContext, hDevice, propName, propSize, pPropValue, pPropSizeRet); @@ -2011,10 +2227,12 @@ __urdlllocal ur_result_t UR_APICALL urVirtualMemGranularityGetInfo( "urVirtualMemGranularityGetInfo", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_VIRTUAL_MEM_GRANULARITY_GET_INFO, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_VIRTUAL_MEM_GRANULARITY_GET_INFO, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -2044,17 +2262,21 @@ __urdlllocal ur_result_t UR_APICALL urVirtualMemReserve( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_VIRTUAL_MEM_RESERVE, "urVirtualMemReserve", ¶ms); - getContext()->logger.info("---> urVirtualMemReserve"); + auto &logger = getContext()->logger; + + logger.info("---> urVirtualMemReserve"); ur_result_t result = pfnReserve(hContext, pStart, size, ppStart); getContext()->notify_end(UR_FUNCTION_VIRTUAL_MEM_RESERVE, "urVirtualMemReserve", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_VIRTUAL_MEM_RESERVE, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_VIRTUAL_MEM_RESERVE, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -2077,17 +2299,21 @@ __urdlllocal ur_result_t UR_APICALL urVirtualMemFree( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_VIRTUAL_MEM_FREE, "urVirtualMemFree", ¶ms); - getContext()->logger.info("---> urVirtualMemFree"); + auto &logger = getContext()->logger; + + logger.info("---> urVirtualMemFree"); ur_result_t result = pfnFree(hContext, pStart, size); getContext()->notify_end(UR_FUNCTION_VIRTUAL_MEM_FREE, "urVirtualMemFree", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_VIRTUAL_MEM_FREE, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_VIRTUAL_MEM_FREE, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -2117,7 +2343,9 @@ __urdlllocal ur_result_t UR_APICALL urVirtualMemMap( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_VIRTUAL_MEM_MAP, "urVirtualMemMap", ¶ms); - getContext()->logger.info("---> urVirtualMemMap"); + auto &logger = getContext()->logger; + + logger.info("---> urVirtualMemMap"); ur_result_t result = pfnMap(hContext, pStart, size, hPhysicalMem, offset, flags); @@ -2125,10 +2353,12 @@ __urdlllocal ur_result_t UR_APICALL urVirtualMemMap( getContext()->notify_end(UR_FUNCTION_VIRTUAL_MEM_MAP, "urVirtualMemMap", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_VIRTUAL_MEM_MAP, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_VIRTUAL_MEM_MAP, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -2151,17 +2381,21 @@ __urdlllocal ur_result_t UR_APICALL urVirtualMemUnmap( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_VIRTUAL_MEM_UNMAP, "urVirtualMemUnmap", ¶ms); - getContext()->logger.info("---> urVirtualMemUnmap"); + auto &logger = getContext()->logger; + + logger.info("---> urVirtualMemUnmap"); ur_result_t result = pfnUnmap(hContext, pStart, size); getContext()->notify_end(UR_FUNCTION_VIRTUAL_MEM_UNMAP, "urVirtualMemUnmap", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_VIRTUAL_MEM_UNMAP, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_VIRTUAL_MEM_UNMAP, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -2187,7 +2421,9 @@ __urdlllocal ur_result_t UR_APICALL urVirtualMemSetAccess( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_VIRTUAL_MEM_SET_ACCESS, "urVirtualMemSetAccess", ¶ms); - getContext()->logger.info("---> urVirtualMemSetAccess"); + auto &logger = getContext()->logger; + + logger.info("---> urVirtualMemSetAccess"); ur_result_t result = pfnSetAccess(hContext, pStart, size, flags); @@ -2195,10 +2431,12 @@ __urdlllocal ur_result_t UR_APICALL urVirtualMemSetAccess( "urVirtualMemSetAccess", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_VIRTUAL_MEM_SET_ACCESS, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_VIRTUAL_MEM_SET_ACCESS, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -2233,7 +2471,9 @@ __urdlllocal ur_result_t UR_APICALL urVirtualMemGetInfo( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_VIRTUAL_MEM_GET_INFO, "urVirtualMemGetInfo", ¶ms); - getContext()->logger.info("---> urVirtualMemGetInfo"); + auto &logger = getContext()->logger; + + logger.info("---> urVirtualMemGetInfo"); ur_result_t result = pfnGetInfo(hContext, pStart, size, propName, propSize, pPropValue, pPropSizeRet); @@ -2241,10 +2481,12 @@ __urdlllocal ur_result_t UR_APICALL urVirtualMemGetInfo( getContext()->notify_end(UR_FUNCTION_VIRTUAL_MEM_GET_INFO, "urVirtualMemGetInfo", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_VIRTUAL_MEM_GET_INFO, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_VIRTUAL_MEM_GET_INFO, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -2273,7 +2515,9 @@ __urdlllocal ur_result_t UR_APICALL urPhysicalMemCreate( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_PHYSICAL_MEM_CREATE, "urPhysicalMemCreate", ¶ms); - getContext()->logger.info("---> urPhysicalMemCreate"); + auto &logger = getContext()->logger; + + logger.info("---> urPhysicalMemCreate"); ur_result_t result = pfnCreate(hContext, hDevice, size, pProperties, phPhysicalMem); @@ -2281,10 +2525,12 @@ __urdlllocal ur_result_t UR_APICALL urPhysicalMemCreate( getContext()->notify_end(UR_FUNCTION_PHYSICAL_MEM_CREATE, "urPhysicalMemCreate", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_PHYSICAL_MEM_CREATE, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_PHYSICAL_MEM_CREATE, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -2305,17 +2551,21 @@ __urdlllocal ur_result_t UR_APICALL urPhysicalMemRetain( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_PHYSICAL_MEM_RETAIN, "urPhysicalMemRetain", ¶ms); - getContext()->logger.info("---> urPhysicalMemRetain"); + auto &logger = getContext()->logger; + + logger.info("---> urPhysicalMemRetain"); ur_result_t result = pfnRetain(hPhysicalMem); getContext()->notify_end(UR_FUNCTION_PHYSICAL_MEM_RETAIN, "urPhysicalMemRetain", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_PHYSICAL_MEM_RETAIN, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_PHYSICAL_MEM_RETAIN, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -2336,7 +2586,9 @@ __urdlllocal ur_result_t UR_APICALL urPhysicalMemRelease( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_PHYSICAL_MEM_RELEASE, "urPhysicalMemRelease", ¶ms); - getContext()->logger.info("---> urPhysicalMemRelease"); + auto &logger = getContext()->logger; + + logger.info("---> urPhysicalMemRelease"); ur_result_t result = pfnRelease(hPhysicalMem); @@ -2344,10 +2596,12 @@ __urdlllocal ur_result_t UR_APICALL urPhysicalMemRelease( "urPhysicalMemRelease", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_PHYSICAL_MEM_RELEASE, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_PHYSICAL_MEM_RELEASE, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -2374,7 +2628,9 @@ __urdlllocal ur_result_t UR_APICALL urProgramCreateWithIL( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_PROGRAM_CREATE_WITH_IL, "urProgramCreateWithIL", ¶ms); - getContext()->logger.info("---> urProgramCreateWithIL"); + auto &logger = getContext()->logger; + + logger.info("---> urProgramCreateWithIL"); ur_result_t result = pfnCreateWithIL(hContext, pIL, length, pProperties, phProgram); @@ -2383,10 +2639,12 @@ __urdlllocal ur_result_t UR_APICALL urProgramCreateWithIL( "urProgramCreateWithIL", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_PROGRAM_CREATE_WITH_IL, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_PROGRAM_CREATE_WITH_IL, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -2417,7 +2675,9 @@ __urdlllocal ur_result_t UR_APICALL urProgramCreateWithBinary( getContext()->notify_begin(UR_FUNCTION_PROGRAM_CREATE_WITH_BINARY, "urProgramCreateWithBinary", ¶ms); - getContext()->logger.info("---> urProgramCreateWithBinary"); + auto &logger = getContext()->logger; + + logger.info("---> urProgramCreateWithBinary"); ur_result_t result = pfnCreateWithBinary(hContext, hDevice, size, pBinary, pProperties, phProgram); @@ -2426,10 +2686,12 @@ __urdlllocal ur_result_t UR_APICALL urProgramCreateWithBinary( "urProgramCreateWithBinary", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_PROGRAM_CREATE_WITH_BINARY, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_PROGRAM_CREATE_WITH_BINARY, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -2452,17 +2714,21 @@ __urdlllocal ur_result_t UR_APICALL urProgramBuild( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_PROGRAM_BUILD, "urProgramBuild", ¶ms); - getContext()->logger.info("---> urProgramBuild"); + auto &logger = getContext()->logger; + + logger.info("---> urProgramBuild"); ur_result_t result = pfnBuild(hContext, hProgram, pOptions); getContext()->notify_end(UR_FUNCTION_PROGRAM_BUILD, "urProgramBuild", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_PROGRAM_BUILD, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_PROGRAM_BUILD, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -2486,17 +2752,21 @@ __urdlllocal ur_result_t UR_APICALL urProgramCompile( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_PROGRAM_COMPILE, "urProgramCompile", ¶ms); - getContext()->logger.info("---> urProgramCompile"); + auto &logger = getContext()->logger; + + logger.info("---> urProgramCompile"); ur_result_t result = pfnCompile(hContext, hProgram, pOptions); getContext()->notify_end(UR_FUNCTION_PROGRAM_COMPILE, "urProgramCompile", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_PROGRAM_COMPILE, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_PROGRAM_COMPILE, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -2527,7 +2797,9 @@ __urdlllocal ur_result_t UR_APICALL urProgramLink( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_PROGRAM_LINK, "urProgramLink", ¶ms); - getContext()->logger.info("---> urProgramLink"); + auto &logger = getContext()->logger; + + logger.info("---> urProgramLink"); ur_result_t result = pfnLink(hContext, count, phPrograms, pOptions, phProgram); @@ -2535,10 +2807,12 @@ __urdlllocal ur_result_t UR_APICALL urProgramLink( getContext()->notify_end(UR_FUNCTION_PROGRAM_LINK, "urProgramLink", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_PROGRAM_LINK, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_PROGRAM_LINK, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -2559,17 +2833,21 @@ __urdlllocal ur_result_t UR_APICALL urProgramRetain( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_PROGRAM_RETAIN, "urProgramRetain", ¶ms); - getContext()->logger.info("---> urProgramRetain"); + auto &logger = getContext()->logger; + + logger.info("---> urProgramRetain"); ur_result_t result = pfnRetain(hProgram); getContext()->notify_end(UR_FUNCTION_PROGRAM_RETAIN, "urProgramRetain", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_PROGRAM_RETAIN, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_PROGRAM_RETAIN, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -2590,17 +2868,21 @@ __urdlllocal ur_result_t UR_APICALL urProgramRelease( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_PROGRAM_RELEASE, "urProgramRelease", ¶ms); - getContext()->logger.info("---> urProgramRelease"); + auto &logger = getContext()->logger; + + logger.info("---> urProgramRelease"); ur_result_t result = pfnRelease(hProgram); getContext()->notify_end(UR_FUNCTION_PROGRAM_RELEASE, "urProgramRelease", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_PROGRAM_RELEASE, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_PROGRAM_RELEASE, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -2632,7 +2914,9 @@ __urdlllocal ur_result_t UR_APICALL urProgramGetFunctionPointer( getContext()->notify_begin(UR_FUNCTION_PROGRAM_GET_FUNCTION_POINTER, "urProgramGetFunctionPointer", ¶ms); - getContext()->logger.info("---> urProgramGetFunctionPointer"); + auto &logger = getContext()->logger; + + logger.info("---> urProgramGetFunctionPointer"); ur_result_t result = pfnGetFunctionPointer(hDevice, hProgram, pFunctionName, ppFunctionPointer); @@ -2641,10 +2925,12 @@ __urdlllocal ur_result_t UR_APICALL urProgramGetFunctionPointer( "urProgramGetFunctionPointer", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_PROGRAM_GET_FUNCTION_POINTER, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_PROGRAM_GET_FUNCTION_POINTER, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -2678,7 +2964,9 @@ __urdlllocal ur_result_t UR_APICALL urProgramGetGlobalVariablePointer( UR_FUNCTION_PROGRAM_GET_GLOBAL_VARIABLE_POINTER, "urProgramGetGlobalVariablePointer", ¶ms); - getContext()->logger.info("---> urProgramGetGlobalVariablePointer"); + auto &logger = getContext()->logger; + + logger.info("---> urProgramGetGlobalVariablePointer"); ur_result_t result = pfnGetGlobalVariablePointer( hDevice, hProgram, pGlobalVariableName, pGlobalVariableSizeRet, @@ -2688,10 +2976,12 @@ __urdlllocal ur_result_t UR_APICALL urProgramGetGlobalVariablePointer( "urProgramGetGlobalVariablePointer", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_PROGRAM_GET_GLOBAL_VARIABLE_POINTER, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_PROGRAM_GET_GLOBAL_VARIABLE_POINTER, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -2723,7 +3013,9 @@ __urdlllocal ur_result_t UR_APICALL urProgramGetInfo( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_PROGRAM_GET_INFO, "urProgramGetInfo", ¶ms); - getContext()->logger.info("---> urProgramGetInfo"); + auto &logger = getContext()->logger; + + logger.info("---> urProgramGetInfo"); ur_result_t result = pfnGetInfo(hProgram, propName, propSize, pPropValue, pPropSizeRet); @@ -2731,10 +3023,12 @@ __urdlllocal ur_result_t UR_APICALL urProgramGetInfo( getContext()->notify_end(UR_FUNCTION_PROGRAM_GET_INFO, "urProgramGetInfo", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_PROGRAM_GET_INFO, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_PROGRAM_GET_INFO, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -2768,7 +3062,9 @@ __urdlllocal ur_result_t UR_APICALL urProgramGetBuildInfo( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_PROGRAM_GET_BUILD_INFO, "urProgramGetBuildInfo", ¶ms); - getContext()->logger.info("---> urProgramGetBuildInfo"); + auto &logger = getContext()->logger; + + logger.info("---> urProgramGetBuildInfo"); ur_result_t result = pfnGetBuildInfo(hProgram, hDevice, propName, propSize, pPropValue, pPropSizeRet); @@ -2777,10 +3073,12 @@ __urdlllocal ur_result_t UR_APICALL urProgramGetBuildInfo( "urProgramGetBuildInfo", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_PROGRAM_GET_BUILD_INFO, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_PROGRAM_GET_BUILD_INFO, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -2807,7 +3105,9 @@ __urdlllocal ur_result_t UR_APICALL urProgramSetSpecializationConstants( UR_FUNCTION_PROGRAM_SET_SPECIALIZATION_CONSTANTS, "urProgramSetSpecializationConstants", ¶ms); - getContext()->logger.info("---> urProgramSetSpecializationConstants"); + auto &logger = getContext()->logger; + + logger.info("---> urProgramSetSpecializationConstants"); ur_result_t result = pfnSetSpecializationConstants(hProgram, count, pSpecConstants); @@ -2816,10 +3116,13 @@ __urdlllocal ur_result_t UR_APICALL urProgramSetSpecializationConstants( "urProgramSetSpecializationConstants", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_PROGRAM_SET_SPECIALIZATION_CONSTANTS, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_PROGRAM_SET_SPECIALIZATION_CONSTANTS, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -2844,7 +3147,9 @@ __urdlllocal ur_result_t UR_APICALL urProgramGetNativeHandle( getContext()->notify_begin(UR_FUNCTION_PROGRAM_GET_NATIVE_HANDLE, "urProgramGetNativeHandle", ¶ms); - getContext()->logger.info("---> urProgramGetNativeHandle"); + auto &logger = getContext()->logger; + + logger.info("---> urProgramGetNativeHandle"); ur_result_t result = pfnGetNativeHandle(hProgram, phNativeProgram); @@ -2852,10 +3157,12 @@ __urdlllocal ur_result_t UR_APICALL urProgramGetNativeHandle( "urProgramGetNativeHandle", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_PROGRAM_GET_NATIVE_HANDLE, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_PROGRAM_GET_NATIVE_HANDLE, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -2884,7 +3191,9 @@ __urdlllocal ur_result_t UR_APICALL urProgramCreateWithNativeHandle( UR_FUNCTION_PROGRAM_CREATE_WITH_NATIVE_HANDLE, "urProgramCreateWithNativeHandle", ¶ms); - getContext()->logger.info("---> urProgramCreateWithNativeHandle"); + auto &logger = getContext()->logger; + + logger.info("---> urProgramCreateWithNativeHandle"); ur_result_t result = pfnCreateWithNativeHandle(hNativeProgram, hContext, pProperties, phProgram); @@ -2893,10 +3202,12 @@ __urdlllocal ur_result_t UR_APICALL urProgramCreateWithNativeHandle( "urProgramCreateWithNativeHandle", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_PROGRAM_CREATE_WITH_NATIVE_HANDLE, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_PROGRAM_CREATE_WITH_NATIVE_HANDLE, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -2919,17 +3230,21 @@ __urdlllocal ur_result_t UR_APICALL urKernelCreate( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_KERNEL_CREATE, "urKernelCreate", ¶ms); - getContext()->logger.info("---> urKernelCreate"); + auto &logger = getContext()->logger; + + logger.info("---> urKernelCreate"); ur_result_t result = pfnCreate(hProgram, pKernelName, phKernel); getContext()->notify_end(UR_FUNCTION_KERNEL_CREATE, "urKernelCreate", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_KERNEL_CREATE, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_KERNEL_CREATE, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -2957,7 +3272,9 @@ __urdlllocal ur_result_t UR_APICALL urKernelSetArgValue( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_KERNEL_SET_ARG_VALUE, "urKernelSetArgValue", ¶ms); - getContext()->logger.info("---> urKernelSetArgValue"); + auto &logger = getContext()->logger; + + logger.info("---> urKernelSetArgValue"); ur_result_t result = pfnSetArgValue(hKernel, argIndex, argSize, pProperties, pArgValue); @@ -2965,10 +3282,12 @@ __urdlllocal ur_result_t UR_APICALL urKernelSetArgValue( getContext()->notify_end(UR_FUNCTION_KERNEL_SET_ARG_VALUE, "urKernelSetArgValue", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_KERNEL_SET_ARG_VALUE, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_KERNEL_SET_ARG_VALUE, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -2994,7 +3313,9 @@ __urdlllocal ur_result_t UR_APICALL urKernelSetArgLocal( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_KERNEL_SET_ARG_LOCAL, "urKernelSetArgLocal", ¶ms); - getContext()->logger.info("---> urKernelSetArgLocal"); + auto &logger = getContext()->logger; + + logger.info("---> urKernelSetArgLocal"); ur_result_t result = pfnSetArgLocal(hKernel, argIndex, argSize, pProperties); @@ -3002,10 +3323,12 @@ __urdlllocal ur_result_t UR_APICALL urKernelSetArgLocal( getContext()->notify_end(UR_FUNCTION_KERNEL_SET_ARG_LOCAL, "urKernelSetArgLocal", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_KERNEL_SET_ARG_LOCAL, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_KERNEL_SET_ARG_LOCAL, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -3038,7 +3361,9 @@ __urdlllocal ur_result_t UR_APICALL urKernelGetInfo( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_KERNEL_GET_INFO, "urKernelGetInfo", ¶ms); - getContext()->logger.info("---> urKernelGetInfo"); + auto &logger = getContext()->logger; + + logger.info("---> urKernelGetInfo"); ur_result_t result = pfnGetInfo(hKernel, propName, propSize, pPropValue, pPropSizeRet); @@ -3046,10 +3371,12 @@ __urdlllocal ur_result_t UR_APICALL urKernelGetInfo( getContext()->notify_end(UR_FUNCTION_KERNEL_GET_INFO, "urKernelGetInfo", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_KERNEL_GET_INFO, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_KERNEL_GET_INFO, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -3080,7 +3407,9 @@ __urdlllocal ur_result_t UR_APICALL urKernelGetGroupInfo( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_KERNEL_GET_GROUP_INFO, "urKernelGetGroupInfo", ¶ms); - getContext()->logger.info("---> urKernelGetGroupInfo"); + auto &logger = getContext()->logger; + + logger.info("---> urKernelGetGroupInfo"); ur_result_t result = pfnGetGroupInfo(hKernel, hDevice, propName, propSize, pPropValue, pPropSizeRet); @@ -3089,10 +3418,12 @@ __urdlllocal ur_result_t UR_APICALL urKernelGetGroupInfo( "urKernelGetGroupInfo", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_KERNEL_GET_GROUP_INFO, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_KERNEL_GET_GROUP_INFO, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -3125,7 +3456,9 @@ __urdlllocal ur_result_t UR_APICALL urKernelGetSubGroupInfo( getContext()->notify_begin(UR_FUNCTION_KERNEL_GET_SUB_GROUP_INFO, "urKernelGetSubGroupInfo", ¶ms); - getContext()->logger.info("---> urKernelGetSubGroupInfo"); + auto &logger = getContext()->logger; + + logger.info("---> urKernelGetSubGroupInfo"); ur_result_t result = pfnGetSubGroupInfo(hKernel, hDevice, propName, propSize, pPropValue, pPropSizeRet); @@ -3134,10 +3467,12 @@ __urdlllocal ur_result_t UR_APICALL urKernelGetSubGroupInfo( "urKernelGetSubGroupInfo", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_KERNEL_GET_SUB_GROUP_INFO, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_KERNEL_GET_SUB_GROUP_INFO, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -3157,17 +3492,21 @@ __urdlllocal ur_result_t UR_APICALL urKernelRetain( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_KERNEL_RETAIN, "urKernelRetain", ¶ms); - getContext()->logger.info("---> urKernelRetain"); + auto &logger = getContext()->logger; + + logger.info("---> urKernelRetain"); ur_result_t result = pfnRetain(hKernel); getContext()->notify_end(UR_FUNCTION_KERNEL_RETAIN, "urKernelRetain", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_KERNEL_RETAIN, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_KERNEL_RETAIN, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -3188,17 +3527,21 @@ __urdlllocal ur_result_t UR_APICALL urKernelRelease( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_KERNEL_RELEASE, "urKernelRelease", ¶ms); - getContext()->logger.info("---> urKernelRelease"); + auto &logger = getContext()->logger; + + logger.info("---> urKernelRelease"); ur_result_t result = pfnRelease(hKernel); getContext()->notify_end(UR_FUNCTION_KERNEL_RELEASE, "urKernelRelease", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_KERNEL_RELEASE, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_KERNEL_RELEASE, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -3225,7 +3568,9 @@ __urdlllocal ur_result_t UR_APICALL urKernelSetArgPointer( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_KERNEL_SET_ARG_POINTER, "urKernelSetArgPointer", ¶ms); - getContext()->logger.info("---> urKernelSetArgPointer"); + auto &logger = getContext()->logger; + + logger.info("---> urKernelSetArgPointer"); ur_result_t result = pfnSetArgPointer(hKernel, argIndex, pProperties, pArgValue); @@ -3234,10 +3579,12 @@ __urdlllocal ur_result_t UR_APICALL urKernelSetArgPointer( "urKernelSetArgPointer", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_KERNEL_SET_ARG_POINTER, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_KERNEL_SET_ARG_POINTER, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -3265,7 +3612,9 @@ __urdlllocal ur_result_t UR_APICALL urKernelSetExecInfo( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_KERNEL_SET_EXEC_INFO, "urKernelSetExecInfo", ¶ms); - getContext()->logger.info("---> urKernelSetExecInfo"); + auto &logger = getContext()->logger; + + logger.info("---> urKernelSetExecInfo"); ur_result_t result = pfnSetExecInfo(hKernel, propName, propSize, pProperties, pPropValue); @@ -3273,10 +3622,12 @@ __urdlllocal ur_result_t UR_APICALL urKernelSetExecInfo( getContext()->notify_end(UR_FUNCTION_KERNEL_SET_EXEC_INFO, "urKernelSetExecInfo", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_KERNEL_SET_EXEC_INFO, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_KERNEL_SET_EXEC_INFO, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -3301,7 +3652,9 @@ __urdlllocal ur_result_t UR_APICALL urKernelSetArgSampler( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_KERNEL_SET_ARG_SAMPLER, "urKernelSetArgSampler", ¶ms); - getContext()->logger.info("---> urKernelSetArgSampler"); + auto &logger = getContext()->logger; + + logger.info("---> urKernelSetArgSampler"); ur_result_t result = pfnSetArgSampler(hKernel, argIndex, pProperties, hArgValue); @@ -3310,10 +3663,12 @@ __urdlllocal ur_result_t UR_APICALL urKernelSetArgSampler( "urKernelSetArgSampler", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_KERNEL_SET_ARG_SAMPLER, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_KERNEL_SET_ARG_SAMPLER, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -3338,7 +3693,9 @@ __urdlllocal ur_result_t UR_APICALL urKernelSetArgMemObj( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_KERNEL_SET_ARG_MEM_OBJ, "urKernelSetArgMemObj", ¶ms); - getContext()->logger.info("---> urKernelSetArgMemObj"); + auto &logger = getContext()->logger; + + logger.info("---> urKernelSetArgMemObj"); ur_result_t result = pfnSetArgMemObj(hKernel, argIndex, pProperties, hArgValue); @@ -3347,10 +3704,12 @@ __urdlllocal ur_result_t UR_APICALL urKernelSetArgMemObj( "urKernelSetArgMemObj", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_KERNEL_SET_ARG_MEM_OBJ, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_KERNEL_SET_ARG_MEM_OBJ, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -3376,7 +3735,9 @@ __urdlllocal ur_result_t UR_APICALL urKernelSetSpecializationConstants( UR_FUNCTION_KERNEL_SET_SPECIALIZATION_CONSTANTS, "urKernelSetSpecializationConstants", ¶ms); - getContext()->logger.info("---> urKernelSetSpecializationConstants"); + auto &logger = getContext()->logger; + + logger.info("---> urKernelSetSpecializationConstants"); ur_result_t result = pfnSetSpecializationConstants(hKernel, count, pSpecConstants); @@ -3385,10 +3746,12 @@ __urdlllocal ur_result_t UR_APICALL urKernelSetSpecializationConstants( "urKernelSetSpecializationConstants", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_KERNEL_SET_SPECIALIZATION_CONSTANTS, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_KERNEL_SET_SPECIALIZATION_CONSTANTS, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -3412,7 +3775,9 @@ __urdlllocal ur_result_t UR_APICALL urKernelGetNativeHandle( getContext()->notify_begin(UR_FUNCTION_KERNEL_GET_NATIVE_HANDLE, "urKernelGetNativeHandle", ¶ms); - getContext()->logger.info("---> urKernelGetNativeHandle"); + auto &logger = getContext()->logger; + + logger.info("---> urKernelGetNativeHandle"); ur_result_t result = pfnGetNativeHandle(hKernel, phNativeKernel); @@ -3420,10 +3785,12 @@ __urdlllocal ur_result_t UR_APICALL urKernelGetNativeHandle( "urKernelGetNativeHandle", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_KERNEL_GET_NATIVE_HANDLE, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_KERNEL_GET_NATIVE_HANDLE, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -3454,7 +3821,9 @@ __urdlllocal ur_result_t UR_APICALL urKernelCreateWithNativeHandle( getContext()->notify_begin(UR_FUNCTION_KERNEL_CREATE_WITH_NATIVE_HANDLE, "urKernelCreateWithNativeHandle", ¶ms); - getContext()->logger.info("---> urKernelCreateWithNativeHandle"); + auto &logger = getContext()->logger; + + logger.info("---> urKernelCreateWithNativeHandle"); ur_result_t result = pfnCreateWithNativeHandle( hNativeKernel, hContext, hProgram, pProperties, phKernel); @@ -3463,10 +3832,12 @@ __urdlllocal ur_result_t UR_APICALL urKernelCreateWithNativeHandle( "urKernelCreateWithNativeHandle", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_KERNEL_CREATE_WITH_NATIVE_HANDLE, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_KERNEL_CREATE_WITH_NATIVE_HANDLE, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -3504,7 +3875,9 @@ __urdlllocal ur_result_t UR_APICALL urKernelGetSuggestedLocalWorkSize( UR_FUNCTION_KERNEL_GET_SUGGESTED_LOCAL_WORK_SIZE, "urKernelGetSuggestedLocalWorkSize", ¶ms); - getContext()->logger.info("---> urKernelGetSuggestedLocalWorkSize"); + auto &logger = getContext()->logger; + + logger.info("---> urKernelGetSuggestedLocalWorkSize"); ur_result_t result = pfnGetSuggestedLocalWorkSize( hKernel, hQueue, numWorkDim, pGlobalWorkOffset, pGlobalWorkSize, @@ -3514,10 +3887,13 @@ __urdlllocal ur_result_t UR_APICALL urKernelGetSuggestedLocalWorkSize( "urKernelGetSuggestedLocalWorkSize", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_KERNEL_GET_SUGGESTED_LOCAL_WORK_SIZE, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_KERNEL_GET_SUGGESTED_LOCAL_WORK_SIZE, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -3546,7 +3922,9 @@ __urdlllocal ur_result_t UR_APICALL urQueueGetInfo( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_QUEUE_GET_INFO, "urQueueGetInfo", ¶ms); - getContext()->logger.info("---> urQueueGetInfo"); + auto &logger = getContext()->logger; + + logger.info("---> urQueueGetInfo"); ur_result_t result = pfnGetInfo(hQueue, propName, propSize, pPropValue, pPropSizeRet); @@ -3554,10 +3932,12 @@ __urdlllocal ur_result_t UR_APICALL urQueueGetInfo( getContext()->notify_end(UR_FUNCTION_QUEUE_GET_INFO, "urQueueGetInfo", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_QUEUE_GET_INFO, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_QUEUE_GET_INFO, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -3583,17 +3963,21 @@ __urdlllocal ur_result_t UR_APICALL urQueueCreate( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_QUEUE_CREATE, "urQueueCreate", ¶ms); - getContext()->logger.info("---> urQueueCreate"); + auto &logger = getContext()->logger; + + logger.info("---> urQueueCreate"); ur_result_t result = pfnCreate(hContext, hDevice, pProperties, phQueue); getContext()->notify_end(UR_FUNCTION_QUEUE_CREATE, "urQueueCreate", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_QUEUE_CREATE, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_QUEUE_CREATE, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -3614,17 +3998,21 @@ __urdlllocal ur_result_t UR_APICALL urQueueRetain( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_QUEUE_RETAIN, "urQueueRetain", ¶ms); - getContext()->logger.info("---> urQueueRetain"); + auto &logger = getContext()->logger; + + logger.info("---> urQueueRetain"); ur_result_t result = pfnRetain(hQueue); getContext()->notify_end(UR_FUNCTION_QUEUE_RETAIN, "urQueueRetain", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_QUEUE_RETAIN, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_QUEUE_RETAIN, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -3645,17 +4033,21 @@ __urdlllocal ur_result_t UR_APICALL urQueueRelease( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_QUEUE_RELEASE, "urQueueRelease", ¶ms); - getContext()->logger.info("---> urQueueRelease"); + auto &logger = getContext()->logger; + + logger.info("---> urQueueRelease"); ur_result_t result = pfnRelease(hQueue); getContext()->notify_end(UR_FUNCTION_QUEUE_RELEASE, "urQueueRelease", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_QUEUE_RELEASE, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_QUEUE_RELEASE, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -3680,7 +4072,9 @@ __urdlllocal ur_result_t UR_APICALL urQueueGetNativeHandle( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_QUEUE_GET_NATIVE_HANDLE, "urQueueGetNativeHandle", ¶ms); - getContext()->logger.info("---> urQueueGetNativeHandle"); + auto &logger = getContext()->logger; + + logger.info("---> urQueueGetNativeHandle"); ur_result_t result = pfnGetNativeHandle(hQueue, pDesc, phNativeQueue); @@ -3688,10 +4082,12 @@ __urdlllocal ur_result_t UR_APICALL urQueueGetNativeHandle( "urQueueGetNativeHandle", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_QUEUE_GET_NATIVE_HANDLE, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_QUEUE_GET_NATIVE_HANDLE, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -3721,7 +4117,9 @@ __urdlllocal ur_result_t UR_APICALL urQueueCreateWithNativeHandle( getContext()->notify_begin(UR_FUNCTION_QUEUE_CREATE_WITH_NATIVE_HANDLE, "urQueueCreateWithNativeHandle", ¶ms); - getContext()->logger.info("---> urQueueCreateWithNativeHandle"); + auto &logger = getContext()->logger; + + logger.info("---> urQueueCreateWithNativeHandle"); ur_result_t result = pfnCreateWithNativeHandle( hNativeQueue, hContext, hDevice, pProperties, phQueue); @@ -3730,10 +4128,12 @@ __urdlllocal ur_result_t UR_APICALL urQueueCreateWithNativeHandle( "urQueueCreateWithNativeHandle", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_QUEUE_CREATE_WITH_NATIVE_HANDLE, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_QUEUE_CREATE_WITH_NATIVE_HANDLE, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -3753,17 +4153,21 @@ __urdlllocal ur_result_t UR_APICALL urQueueFinish( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_QUEUE_FINISH, "urQueueFinish", ¶ms); - getContext()->logger.info("---> urQueueFinish"); + auto &logger = getContext()->logger; + + logger.info("---> urQueueFinish"); ur_result_t result = pfnFinish(hQueue); getContext()->notify_end(UR_FUNCTION_QUEUE_FINISH, "urQueueFinish", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_QUEUE_FINISH, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_QUEUE_FINISH, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -3783,16 +4187,21 @@ __urdlllocal ur_result_t UR_APICALL urQueueFlush( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_QUEUE_FLUSH, "urQueueFlush", ¶ms); - getContext()->logger.info("---> urQueueFlush"); + auto &logger = getContext()->logger; + + logger.info("---> urQueueFlush"); ur_result_t result = pfnFlush(hQueue); getContext()->notify_end(UR_FUNCTION_QUEUE_FLUSH, "urQueueFlush", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_QUEUE_FLUSH, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_QUEUE_FLUSH, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -3819,7 +4228,9 @@ __urdlllocal ur_result_t UR_APICALL urEventGetInfo( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_EVENT_GET_INFO, "urEventGetInfo", ¶ms); - getContext()->logger.info("---> urEventGetInfo"); + auto &logger = getContext()->logger; + + logger.info("---> urEventGetInfo"); ur_result_t result = pfnGetInfo(hEvent, propName, propSize, pPropValue, pPropSizeRet); @@ -3827,10 +4238,12 @@ __urdlllocal ur_result_t UR_APICALL urEventGetInfo( getContext()->notify_end(UR_FUNCTION_EVENT_GET_INFO, "urEventGetInfo", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_EVENT_GET_INFO, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_EVENT_GET_INFO, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -3862,7 +4275,9 @@ __urdlllocal ur_result_t UR_APICALL urEventGetProfilingInfo( getContext()->notify_begin(UR_FUNCTION_EVENT_GET_PROFILING_INFO, "urEventGetProfilingInfo", ¶ms); - getContext()->logger.info("---> urEventGetProfilingInfo"); + auto &logger = getContext()->logger; + + logger.info("---> urEventGetProfilingInfo"); ur_result_t result = pfnGetProfilingInfo(hEvent, propName, propSize, pPropValue, pPropSizeRet); @@ -3871,10 +4286,12 @@ __urdlllocal ur_result_t UR_APICALL urEventGetProfilingInfo( "urEventGetProfilingInfo", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_EVENT_GET_PROFILING_INFO, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_EVENT_GET_PROFILING_INFO, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -3897,16 +4314,21 @@ __urdlllocal ur_result_t UR_APICALL urEventWait( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_EVENT_WAIT, "urEventWait", ¶ms); - getContext()->logger.info("---> urEventWait"); + auto &logger = getContext()->logger; + + logger.info("---> urEventWait"); ur_result_t result = pfnWait(numEvents, phEventWaitList); getContext()->notify_end(UR_FUNCTION_EVENT_WAIT, "urEventWait", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_EVENT_WAIT, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_EVENT_WAIT, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -3926,17 +4348,21 @@ __urdlllocal ur_result_t UR_APICALL urEventRetain( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_EVENT_RETAIN, "urEventRetain", ¶ms); - getContext()->logger.info("---> urEventRetain"); + auto &logger = getContext()->logger; + + logger.info("---> urEventRetain"); ur_result_t result = pfnRetain(hEvent); getContext()->notify_end(UR_FUNCTION_EVENT_RETAIN, "urEventRetain", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_EVENT_RETAIN, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_EVENT_RETAIN, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -3956,17 +4382,21 @@ __urdlllocal ur_result_t UR_APICALL urEventRelease( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_EVENT_RELEASE, "urEventRelease", ¶ms); - getContext()->logger.info("---> urEventRelease"); + auto &logger = getContext()->logger; + + logger.info("---> urEventRelease"); ur_result_t result = pfnRelease(hEvent); getContext()->notify_end(UR_FUNCTION_EVENT_RELEASE, "urEventRelease", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_EVENT_RELEASE, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_EVENT_RELEASE, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -3988,7 +4418,9 @@ __urdlllocal ur_result_t UR_APICALL urEventGetNativeHandle( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_EVENT_GET_NATIVE_HANDLE, "urEventGetNativeHandle", ¶ms); - getContext()->logger.info("---> urEventGetNativeHandle"); + auto &logger = getContext()->logger; + + logger.info("---> urEventGetNativeHandle"); ur_result_t result = pfnGetNativeHandle(hEvent, phNativeEvent); @@ -3996,10 +4428,12 @@ __urdlllocal ur_result_t UR_APICALL urEventGetNativeHandle( "urEventGetNativeHandle", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_EVENT_GET_NATIVE_HANDLE, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_EVENT_GET_NATIVE_HANDLE, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -4028,7 +4462,9 @@ __urdlllocal ur_result_t UR_APICALL urEventCreateWithNativeHandle( getContext()->notify_begin(UR_FUNCTION_EVENT_CREATE_WITH_NATIVE_HANDLE, "urEventCreateWithNativeHandle", ¶ms); - getContext()->logger.info("---> urEventCreateWithNativeHandle"); + auto &logger = getContext()->logger; + + logger.info("---> urEventCreateWithNativeHandle"); ur_result_t result = pfnCreateWithNativeHandle(hNativeEvent, hContext, pProperties, phEvent); @@ -4037,10 +4473,12 @@ __urdlllocal ur_result_t UR_APICALL urEventCreateWithNativeHandle( "urEventCreateWithNativeHandle", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_EVENT_CREATE_WITH_NATIVE_HANDLE, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_EVENT_CREATE_WITH_NATIVE_HANDLE, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -4065,7 +4503,9 @@ __urdlllocal ur_result_t UR_APICALL urEventSetCallback( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_EVENT_SET_CALLBACK, "urEventSetCallback", ¶ms); - getContext()->logger.info("---> urEventSetCallback"); + auto &logger = getContext()->logger; + + logger.info("---> urEventSetCallback"); ur_result_t result = pfnSetCallback(hEvent, execStatus, pfnNotify, pUserData); @@ -4073,10 +4513,12 @@ __urdlllocal ur_result_t UR_APICALL urEventSetCallback( getContext()->notify_end(UR_FUNCTION_EVENT_SET_CALLBACK, "urEventSetCallback", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_EVENT_SET_CALLBACK, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_EVENT_SET_CALLBACK, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -4130,7 +4572,9 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueKernelLaunch( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_ENQUEUE_KERNEL_LAUNCH, "urEnqueueKernelLaunch", ¶ms); - getContext()->logger.info("---> urEnqueueKernelLaunch"); + auto &logger = getContext()->logger; + + logger.info("---> urEnqueueKernelLaunch"); ur_result_t result = pfnKernelLaunch( hQueue, hKernel, workDim, pGlobalWorkOffset, pGlobalWorkSize, @@ -4140,10 +4584,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueKernelLaunch( "urEnqueueKernelLaunch", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_ENQUEUE_KERNEL_LAUNCH, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_ENQUEUE_KERNEL_LAUNCH, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -4174,7 +4620,9 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueEventsWait( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_ENQUEUE_EVENTS_WAIT, "urEnqueueEventsWait", ¶ms); - getContext()->logger.info("---> urEnqueueEventsWait"); + auto &logger = getContext()->logger; + + logger.info("---> urEnqueueEventsWait"); ur_result_t result = pfnEventsWait(hQueue, numEventsInWaitList, phEventWaitList, phEvent); @@ -4182,10 +4630,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueEventsWait( getContext()->notify_end(UR_FUNCTION_ENQUEUE_EVENTS_WAIT, "urEnqueueEventsWait", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_ENQUEUE_EVENTS_WAIT, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_ENQUEUE_EVENTS_WAIT, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -4218,7 +4668,9 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueEventsWaitWithBarrier( getContext()->notify_begin(UR_FUNCTION_ENQUEUE_EVENTS_WAIT_WITH_BARRIER, "urEnqueueEventsWaitWithBarrier", ¶ms); - getContext()->logger.info("---> urEnqueueEventsWaitWithBarrier"); + auto &logger = getContext()->logger; + + logger.info("---> urEnqueueEventsWaitWithBarrier"); ur_result_t result = pfnEventsWaitWithBarrier(hQueue, numEventsInWaitList, phEventWaitList, phEvent); @@ -4227,10 +4679,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueEventsWaitWithBarrier( "urEnqueueEventsWaitWithBarrier", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ENQUEUE_EVENTS_WAIT_WITH_BARRIER, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_ENQUEUE_EVENTS_WAIT_WITH_BARRIER, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -4268,7 +4722,9 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemBufferRead( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_ENQUEUE_MEM_BUFFER_READ, "urEnqueueMemBufferRead", ¶ms); - getContext()->logger.info("---> urEnqueueMemBufferRead"); + auto &logger = getContext()->logger; + + logger.info("---> urEnqueueMemBufferRead"); ur_result_t result = pfnMemBufferRead(hQueue, hBuffer, blockingRead, offset, size, pDst, @@ -4278,10 +4734,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemBufferRead( "urEnqueueMemBufferRead", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ENQUEUE_MEM_BUFFER_READ, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_ENQUEUE_MEM_BUFFER_READ, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -4322,7 +4780,9 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemBufferWrite( getContext()->notify_begin(UR_FUNCTION_ENQUEUE_MEM_BUFFER_WRITE, "urEnqueueMemBufferWrite", ¶ms); - getContext()->logger.info("---> urEnqueueMemBufferWrite"); + auto &logger = getContext()->logger; + + logger.info("---> urEnqueueMemBufferWrite"); ur_result_t result = pfnMemBufferWrite(hQueue, hBuffer, blockingWrite, offset, size, pSrc, @@ -4332,10 +4792,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemBufferWrite( "urEnqueueMemBufferWrite", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ENQUEUE_MEM_BUFFER_WRITE, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_ENQUEUE_MEM_BUFFER_WRITE, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -4397,7 +4859,9 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemBufferReadRect( getContext()->notify_begin(UR_FUNCTION_ENQUEUE_MEM_BUFFER_READ_RECT, "urEnqueueMemBufferReadRect", ¶ms); - getContext()->logger.info("---> urEnqueueMemBufferReadRect"); + auto &logger = getContext()->logger; + + logger.info("---> urEnqueueMemBufferReadRect"); ur_result_t result = pfnMemBufferReadRect( hQueue, hBuffer, blockingRead, bufferOrigin, hostOrigin, region, @@ -4408,10 +4872,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemBufferReadRect( "urEnqueueMemBufferReadRect", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ENQUEUE_MEM_BUFFER_READ_RECT, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_ENQUEUE_MEM_BUFFER_READ_RECT, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -4476,7 +4942,9 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemBufferWriteRect( getContext()->notify_begin(UR_FUNCTION_ENQUEUE_MEM_BUFFER_WRITE_RECT, "urEnqueueMemBufferWriteRect", ¶ms); - getContext()->logger.info("---> urEnqueueMemBufferWriteRect"); + auto &logger = getContext()->logger; + + logger.info("---> urEnqueueMemBufferWriteRect"); ur_result_t result = pfnMemBufferWriteRect( hQueue, hBuffer, blockingWrite, bufferOrigin, hostOrigin, region, @@ -4487,10 +4955,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemBufferWriteRect( "urEnqueueMemBufferWriteRect", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ENQUEUE_MEM_BUFFER_WRITE_RECT, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_ENQUEUE_MEM_BUFFER_WRITE_RECT, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -4528,7 +4998,9 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemBufferCopy( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_ENQUEUE_MEM_BUFFER_COPY, "urEnqueueMemBufferCopy", ¶ms); - getContext()->logger.info("---> urEnqueueMemBufferCopy"); + auto &logger = getContext()->logger; + + logger.info("---> urEnqueueMemBufferCopy"); ur_result_t result = pfnMemBufferCopy(hQueue, hBufferSrc, hBufferDst, srcOffset, dstOffset, @@ -4538,10 +5010,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemBufferCopy( "urEnqueueMemBufferCopy", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ENQUEUE_MEM_BUFFER_COPY, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_ENQUEUE_MEM_BUFFER_COPY, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -4592,7 +5066,9 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemBufferCopyRect( getContext()->notify_begin(UR_FUNCTION_ENQUEUE_MEM_BUFFER_COPY_RECT, "urEnqueueMemBufferCopyRect", ¶ms); - getContext()->logger.info("---> urEnqueueMemBufferCopyRect"); + auto &logger = getContext()->logger; + + logger.info("---> urEnqueueMemBufferCopyRect"); ur_result_t result = pfnMemBufferCopyRect( hQueue, hBufferSrc, hBufferDst, srcOrigin, dstOrigin, region, @@ -4603,10 +5079,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemBufferCopyRect( "urEnqueueMemBufferCopyRect", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ENQUEUE_MEM_BUFFER_COPY_RECT, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_ENQUEUE_MEM_BUFFER_COPY_RECT, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -4649,7 +5127,9 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemBufferFill( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_ENQUEUE_MEM_BUFFER_FILL, "urEnqueueMemBufferFill", ¶ms); - getContext()->logger.info("---> urEnqueueMemBufferFill"); + auto &logger = getContext()->logger; + + logger.info("---> urEnqueueMemBufferFill"); ur_result_t result = pfnMemBufferFill(hQueue, hBuffer, pPattern, patternSize, offset, size, @@ -4659,10 +5139,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemBufferFill( "urEnqueueMemBufferFill", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ENQUEUE_MEM_BUFFER_FILL, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_ENQUEUE_MEM_BUFFER_FILL, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -4706,7 +5188,9 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemImageRead( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_ENQUEUE_MEM_IMAGE_READ, "urEnqueueMemImageRead", ¶ms); - getContext()->logger.info("---> urEnqueueMemImageRead"); + auto &logger = getContext()->logger; + + logger.info("---> urEnqueueMemImageRead"); ur_result_t result = pfnMemImageRead( hQueue, hImage, blockingRead, origin, region, rowPitch, slicePitch, @@ -4716,10 +5200,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemImageRead( "urEnqueueMemImageRead", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ENQUEUE_MEM_IMAGE_READ, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_ENQUEUE_MEM_IMAGE_READ, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -4764,7 +5250,9 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemImageWrite( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_ENQUEUE_MEM_IMAGE_WRITE, "urEnqueueMemImageWrite", ¶ms); - getContext()->logger.info("---> urEnqueueMemImageWrite"); + auto &logger = getContext()->logger; + + logger.info("---> urEnqueueMemImageWrite"); ur_result_t result = pfnMemImageWrite( hQueue, hImage, blockingWrite, origin, region, rowPitch, slicePitch, @@ -4774,10 +5262,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemImageWrite( "urEnqueueMemImageWrite", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ENQUEUE_MEM_IMAGE_WRITE, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_ENQUEUE_MEM_IMAGE_WRITE, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -4821,7 +5311,9 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemImageCopy( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_ENQUEUE_MEM_IMAGE_COPY, "urEnqueueMemImageCopy", ¶ms); - getContext()->logger.info("---> urEnqueueMemImageCopy"); + auto &logger = getContext()->logger; + + logger.info("---> urEnqueueMemImageCopy"); ur_result_t result = pfnMemImageCopy(hQueue, hImageSrc, hImageDst, srcOrigin, dstOrigin, @@ -4831,10 +5323,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemImageCopy( "urEnqueueMemImageCopy", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ENQUEUE_MEM_IMAGE_COPY, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_ENQUEUE_MEM_IMAGE_COPY, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -4874,7 +5368,9 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemBufferMap( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_ENQUEUE_MEM_BUFFER_MAP, "urEnqueueMemBufferMap", ¶ms); - getContext()->logger.info("---> urEnqueueMemBufferMap"); + auto &logger = getContext()->logger; + + logger.info("---> urEnqueueMemBufferMap"); ur_result_t result = pfnMemBufferMap(hQueue, hBuffer, blockingMap, mapFlags, offset, size, numEventsInWaitList, @@ -4884,10 +5380,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemBufferMap( "urEnqueueMemBufferMap", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ENQUEUE_MEM_BUFFER_MAP, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_ENQUEUE_MEM_BUFFER_MAP, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -4921,7 +5419,9 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemUnmap( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_ENQUEUE_MEM_UNMAP, "urEnqueueMemUnmap", ¶ms); - getContext()->logger.info("---> urEnqueueMemUnmap"); + auto &logger = getContext()->logger; + + logger.info("---> urEnqueueMemUnmap"); ur_result_t result = pfnMemUnmap(hQueue, hMem, pMappedPtr, numEventsInWaitList, @@ -4930,10 +5430,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemUnmap( getContext()->notify_end(UR_FUNCTION_ENQUEUE_MEM_UNMAP, "urEnqueueMemUnmap", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_ENQUEUE_MEM_UNMAP, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_ENQUEUE_MEM_UNMAP, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -4973,7 +5475,9 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueUSMFill( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_ENQUEUE_USM_FILL, "urEnqueueUSMFill", ¶ms); - getContext()->logger.info("---> urEnqueueUSMFill"); + auto &logger = getContext()->logger; + + logger.info("---> urEnqueueUSMFill"); ur_result_t result = pfnUSMFill(hQueue, pMem, patternSize, pPattern, size, @@ -4982,10 +5486,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueUSMFill( getContext()->notify_end(UR_FUNCTION_ENQUEUE_USM_FILL, "urEnqueueUSMFill", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_ENQUEUE_USM_FILL, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_ENQUEUE_USM_FILL, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -5022,7 +5528,9 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueUSMMemcpy( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_ENQUEUE_USM_MEMCPY, "urEnqueueUSMMemcpy", ¶ms); - getContext()->logger.info("---> urEnqueueUSMMemcpy"); + auto &logger = getContext()->logger; + + logger.info("---> urEnqueueUSMMemcpy"); ur_result_t result = pfnUSMMemcpy(hQueue, blocking, pDst, pSrc, size, numEventsInWaitList, @@ -5031,10 +5539,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueUSMMemcpy( getContext()->notify_end(UR_FUNCTION_ENQUEUE_USM_MEMCPY, "urEnqueueUSMMemcpy", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_ENQUEUE_USM_MEMCPY, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_ENQUEUE_USM_MEMCPY, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -5069,7 +5579,9 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueUSMPrefetch( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_ENQUEUE_USM_PREFETCH, "urEnqueueUSMPrefetch", ¶ms); - getContext()->logger.info("---> urEnqueueUSMPrefetch"); + auto &logger = getContext()->logger; + + logger.info("---> urEnqueueUSMPrefetch"); ur_result_t result = pfnUSMPrefetch(hQueue, pMem, size, flags, numEventsInWaitList, @@ -5079,10 +5591,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueUSMPrefetch( "urEnqueueUSMPrefetch", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_ENQUEUE_USM_PREFETCH, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_ENQUEUE_USM_PREFETCH, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -5110,17 +5624,21 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueUSMAdvise( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_ENQUEUE_USM_ADVISE, "urEnqueueUSMAdvise", ¶ms); - getContext()->logger.info("---> urEnqueueUSMAdvise"); + auto &logger = getContext()->logger; + + logger.info("---> urEnqueueUSMAdvise"); ur_result_t result = pfnUSMAdvise(hQueue, pMem, size, advice, phEvent); getContext()->notify_end(UR_FUNCTION_ENQUEUE_USM_ADVISE, "urEnqueueUSMAdvise", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_ENQUEUE_USM_ADVISE, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_ENQUEUE_USM_ADVISE, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -5165,7 +5683,9 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueUSMFill2D( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_ENQUEUE_USM_FILL_2D, "urEnqueueUSMFill2D", ¶ms); - getContext()->logger.info("---> urEnqueueUSMFill2D"); + auto &logger = getContext()->logger; + + logger.info("---> urEnqueueUSMFill2D"); ur_result_t result = pfnUSMFill2D(hQueue, pMem, pitch, patternSize, pPattern, width, height, @@ -5174,10 +5694,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueUSMFill2D( getContext()->notify_end(UR_FUNCTION_ENQUEUE_USM_FILL_2D, "urEnqueueUSMFill2D", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_ENQUEUE_USM_FILL_2D, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_ENQUEUE_USM_FILL_2D, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -5222,7 +5744,9 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueUSMMemcpy2D( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_ENQUEUE_USM_MEMCPY_2D, "urEnqueueUSMMemcpy2D", ¶ms); - getContext()->logger.info("---> urEnqueueUSMMemcpy2D"); + auto &logger = getContext()->logger; + + logger.info("---> urEnqueueUSMMemcpy2D"); ur_result_t result = pfnUSMMemcpy2D(hQueue, blocking, pDst, dstPitch, pSrc, srcPitch, width, @@ -5232,10 +5756,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueUSMMemcpy2D( "urEnqueueUSMMemcpy2D", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_ENQUEUE_USM_MEMCPY_2D, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_ENQUEUE_USM_MEMCPY_2D, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -5278,7 +5804,9 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueDeviceGlobalVariableWrite( UR_FUNCTION_ENQUEUE_DEVICE_GLOBAL_VARIABLE_WRITE, "urEnqueueDeviceGlobalVariableWrite", ¶ms); - getContext()->logger.info("---> urEnqueueDeviceGlobalVariableWrite"); + auto &logger = getContext()->logger; + + logger.info("---> urEnqueueDeviceGlobalVariableWrite"); ur_result_t result = pfnDeviceGlobalVariableWrite( hQueue, hProgram, name, blockingWrite, count, offset, pSrc, @@ -5288,10 +5816,13 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueDeviceGlobalVariableWrite( "urEnqueueDeviceGlobalVariableWrite", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ENQUEUE_DEVICE_GLOBAL_VARIABLE_WRITE, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_ENQUEUE_DEVICE_GLOBAL_VARIABLE_WRITE, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -5334,7 +5865,9 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueDeviceGlobalVariableRead( UR_FUNCTION_ENQUEUE_DEVICE_GLOBAL_VARIABLE_READ, "urEnqueueDeviceGlobalVariableRead", ¶ms); - getContext()->logger.info("---> urEnqueueDeviceGlobalVariableRead"); + auto &logger = getContext()->logger; + + logger.info("---> urEnqueueDeviceGlobalVariableRead"); ur_result_t result = pfnDeviceGlobalVariableRead( hQueue, hProgram, name, blockingRead, count, offset, pDst, @@ -5344,10 +5877,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueDeviceGlobalVariableRead( "urEnqueueDeviceGlobalVariableRead", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ENQUEUE_DEVICE_GLOBAL_VARIABLE_READ, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_ENQUEUE_DEVICE_GLOBAL_VARIABLE_READ, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -5392,7 +5927,9 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueReadHostPipe( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_ENQUEUE_READ_HOST_PIPE, "urEnqueueReadHostPipe", ¶ms); - getContext()->logger.info("---> urEnqueueReadHostPipe"); + auto &logger = getContext()->logger; + + logger.info("---> urEnqueueReadHostPipe"); ur_result_t result = pfnReadHostPipe(hQueue, hProgram, pipe_symbol, blocking, pDst, size, @@ -5402,10 +5939,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueReadHostPipe( "urEnqueueReadHostPipe", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ENQUEUE_READ_HOST_PIPE, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_ENQUEUE_READ_HOST_PIPE, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -5450,7 +5989,9 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueWriteHostPipe( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_ENQUEUE_WRITE_HOST_PIPE, "urEnqueueWriteHostPipe", ¶ms); - getContext()->logger.info("---> urEnqueueWriteHostPipe"); + auto &logger = getContext()->logger; + + logger.info("---> urEnqueueWriteHostPipe"); ur_result_t result = pfnWriteHostPipe(hQueue, hProgram, pipe_symbol, blocking, pSrc, size, @@ -5460,10 +6001,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueWriteHostPipe( "urEnqueueWriteHostPipe", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ENQUEUE_WRITE_HOST_PIPE, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_ENQUEUE_WRITE_HOST_PIPE, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -5498,7 +6041,9 @@ __urdlllocal ur_result_t UR_APICALL urUSMPitchedAllocExp( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_USM_PITCHED_ALLOC_EXP, "urUSMPitchedAllocExp", ¶ms); - getContext()->logger.info("---> urUSMPitchedAllocExp"); + auto &logger = getContext()->logger; + + logger.info("---> urUSMPitchedAllocExp"); ur_result_t result = pfnPitchedAllocExp(hContext, hDevice, pUSMDesc, pool, widthInBytes, @@ -5508,10 +6053,12 @@ __urdlllocal ur_result_t UR_APICALL urUSMPitchedAllocExp( "urUSMPitchedAllocExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_USM_PITCHED_ALLOC_EXP, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_USM_PITCHED_ALLOC_EXP, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -5539,8 +6086,9 @@ urBindlessImagesUnsampledImageHandleDestroyExp( UR_FUNCTION_BINDLESS_IMAGES_UNSAMPLED_IMAGE_HANDLE_DESTROY_EXP, "urBindlessImagesUnsampledImageHandleDestroyExp", ¶ms); - getContext()->logger.info( - "---> urBindlessImagesUnsampledImageHandleDestroyExp"); + auto &logger = getContext()->logger; + + logger.info("---> urBindlessImagesUnsampledImageHandleDestroyExp"); ur_result_t result = pfnUnsampledImageHandleDestroyExp(hContext, hDevice, hImage); @@ -5550,12 +6098,14 @@ urBindlessImagesUnsampledImageHandleDestroyExp( "urBindlessImagesUnsampledImageHandleDestroyExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, - UR_FUNCTION_BINDLESS_IMAGES_UNSAMPLED_IMAGE_HANDLE_DESTROY_EXP, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, + UR_FUNCTION_BINDLESS_IMAGES_UNSAMPLED_IMAGE_HANDLE_DESTROY_EXP, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -5583,8 +6133,9 @@ urBindlessImagesSampledImageHandleDestroyExp( UR_FUNCTION_BINDLESS_IMAGES_SAMPLED_IMAGE_HANDLE_DESTROY_EXP, "urBindlessImagesSampledImageHandleDestroyExp", ¶ms); - getContext()->logger.info( - "---> urBindlessImagesSampledImageHandleDestroyExp"); + auto &logger = getContext()->logger; + + logger.info("---> urBindlessImagesSampledImageHandleDestroyExp"); ur_result_t result = pfnSampledImageHandleDestroyExp(hContext, hDevice, hImage); @@ -5594,11 +6145,14 @@ urBindlessImagesSampledImageHandleDestroyExp( "urBindlessImagesSampledImageHandleDestroyExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_BINDLESS_IMAGES_SAMPLED_IMAGE_HANDLE_DESTROY_EXP, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, + UR_FUNCTION_BINDLESS_IMAGES_SAMPLED_IMAGE_HANDLE_DESTROY_EXP, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -5627,7 +6181,9 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesImageAllocateExp( UR_FUNCTION_BINDLESS_IMAGES_IMAGE_ALLOCATE_EXP, "urBindlessImagesImageAllocateExp", ¶ms); - getContext()->logger.info("---> urBindlessImagesImageAllocateExp"); + auto &logger = getContext()->logger; + + logger.info("---> urBindlessImagesImageAllocateExp"); ur_result_t result = pfnImageAllocateExp(hContext, hDevice, pImageFormat, pImageDesc, phImageMem); @@ -5636,10 +6192,12 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesImageAllocateExp( "urBindlessImagesImageAllocateExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_BINDLESS_IMAGES_IMAGE_ALLOCATE_EXP, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_BINDLESS_IMAGES_IMAGE_ALLOCATE_EXP, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -5665,7 +6223,9 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesImageFreeExp( getContext()->notify_begin(UR_FUNCTION_BINDLESS_IMAGES_IMAGE_FREE_EXP, "urBindlessImagesImageFreeExp", ¶ms); - getContext()->logger.info("---> urBindlessImagesImageFreeExp"); + auto &logger = getContext()->logger; + + logger.info("---> urBindlessImagesImageFreeExp"); ur_result_t result = pfnImageFreeExp(hContext, hDevice, hImageMem); @@ -5673,10 +6233,12 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesImageFreeExp( "urBindlessImagesImageFreeExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_BINDLESS_IMAGES_IMAGE_FREE_EXP, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_BINDLESS_IMAGES_IMAGE_FREE_EXP, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -5707,7 +6269,9 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesUnsampledImageCreateExp( UR_FUNCTION_BINDLESS_IMAGES_UNSAMPLED_IMAGE_CREATE_EXP, "urBindlessImagesUnsampledImageCreateExp", ¶ms); - getContext()->logger.info("---> urBindlessImagesUnsampledImageCreateExp"); + auto &logger = getContext()->logger; + + logger.info("---> urBindlessImagesUnsampledImageCreateExp"); ur_result_t result = pfnUnsampledImageCreateExp( hContext, hDevice, hImageMem, pImageFormat, pImageDesc, phImage); @@ -5716,11 +6280,13 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesUnsampledImageCreateExp( UR_FUNCTION_BINDLESS_IMAGES_UNSAMPLED_IMAGE_CREATE_EXP, "urBindlessImagesUnsampledImageCreateExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_BINDLESS_IMAGES_UNSAMPLED_IMAGE_CREATE_EXP, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_BINDLESS_IMAGES_UNSAMPLED_IMAGE_CREATE_EXP, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -5753,7 +6319,9 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesSampledImageCreateExp( UR_FUNCTION_BINDLESS_IMAGES_SAMPLED_IMAGE_CREATE_EXP, "urBindlessImagesSampledImageCreateExp", ¶ms); - getContext()->logger.info("---> urBindlessImagesSampledImageCreateExp"); + auto &logger = getContext()->logger; + + logger.info("---> urBindlessImagesSampledImageCreateExp"); ur_result_t result = pfnSampledImageCreateExp(hContext, hDevice, hImageMem, pImageFormat, @@ -5763,11 +6331,13 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesSampledImageCreateExp( UR_FUNCTION_BINDLESS_IMAGES_SAMPLED_IMAGE_CREATE_EXP, "urBindlessImagesSampledImageCreateExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_BINDLESS_IMAGES_SAMPLED_IMAGE_CREATE_EXP, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_BINDLESS_IMAGES_SAMPLED_IMAGE_CREATE_EXP, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -5823,7 +6393,9 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesImageCopyExp( getContext()->notify_begin(UR_FUNCTION_BINDLESS_IMAGES_IMAGE_COPY_EXP, "urBindlessImagesImageCopyExp", ¶ms); - getContext()->logger.info("---> urBindlessImagesImageCopyExp"); + auto &logger = getContext()->logger; + + logger.info("---> urBindlessImagesImageCopyExp"); ur_result_t result = pfnImageCopyExp( hQueue, pSrc, pDst, pSrcImageDesc, pDstImageDesc, pSrcImageFormat, @@ -5834,10 +6406,12 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesImageCopyExp( "urBindlessImagesImageCopyExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_BINDLESS_IMAGES_IMAGE_COPY_EXP, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_BINDLESS_IMAGES_IMAGE_COPY_EXP, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -5865,7 +6439,9 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesImageGetInfoExp( UR_FUNCTION_BINDLESS_IMAGES_IMAGE_GET_INFO_EXP, "urBindlessImagesImageGetInfoExp", ¶ms); - getContext()->logger.info("---> urBindlessImagesImageGetInfoExp"); + auto &logger = getContext()->logger; + + logger.info("---> urBindlessImagesImageGetInfoExp"); ur_result_t result = pfnImageGetInfoExp(hContext, hImageMem, propName, pPropValue, pPropSizeRet); @@ -5874,10 +6450,12 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesImageGetInfoExp( "urBindlessImagesImageGetInfoExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_BINDLESS_IMAGES_IMAGE_GET_INFO_EXP, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_BINDLESS_IMAGES_IMAGE_GET_INFO_EXP, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -5906,7 +6484,9 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesMipmapGetLevelExp( UR_FUNCTION_BINDLESS_IMAGES_MIPMAP_GET_LEVEL_EXP, "urBindlessImagesMipmapGetLevelExp", ¶ms); - getContext()->logger.info("---> urBindlessImagesMipmapGetLevelExp"); + auto &logger = getContext()->logger; + + logger.info("---> urBindlessImagesMipmapGetLevelExp"); ur_result_t result = pfnMipmapGetLevelExp(hContext, hDevice, hImageMem, mipmapLevel, phImageMem); @@ -5915,10 +6495,13 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesMipmapGetLevelExp( "urBindlessImagesMipmapGetLevelExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_BINDLESS_IMAGES_MIPMAP_GET_LEVEL_EXP, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_BINDLESS_IMAGES_MIPMAP_GET_LEVEL_EXP, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -5944,7 +6527,9 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesMipmapFreeExp( getContext()->notify_begin(UR_FUNCTION_BINDLESS_IMAGES_MIPMAP_FREE_EXP, "urBindlessImagesMipmapFreeExp", ¶ms); - getContext()->logger.info("---> urBindlessImagesMipmapFreeExp"); + auto &logger = getContext()->logger; + + logger.info("---> urBindlessImagesMipmapFreeExp"); ur_result_t result = pfnMipmapFreeExp(hContext, hDevice, hMem); @@ -5952,10 +6537,12 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesMipmapFreeExp( "urBindlessImagesMipmapFreeExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_BINDLESS_IMAGES_MIPMAP_FREE_EXP, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_BINDLESS_IMAGES_MIPMAP_FREE_EXP, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -5987,7 +6574,9 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesImportExternalMemoryExp( UR_FUNCTION_BINDLESS_IMAGES_IMPORT_EXTERNAL_MEMORY_EXP, "urBindlessImagesImportExternalMemoryExp", ¶ms); - getContext()->logger.info("---> urBindlessImagesImportExternalMemoryExp"); + auto &logger = getContext()->logger; + + logger.info("---> urBindlessImagesImportExternalMemoryExp"); ur_result_t result = pfnImportExternalMemoryExp(hContext, hDevice, size, memHandleType, @@ -5997,11 +6586,13 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesImportExternalMemoryExp( UR_FUNCTION_BINDLESS_IMAGES_IMPORT_EXTERNAL_MEMORY_EXP, "urBindlessImagesImportExternalMemoryExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_BINDLESS_IMAGES_IMPORT_EXTERNAL_MEMORY_EXP, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_BINDLESS_IMAGES_IMPORT_EXTERNAL_MEMORY_EXP, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -6033,7 +6624,9 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesMapExternalArrayExp( UR_FUNCTION_BINDLESS_IMAGES_MAP_EXTERNAL_ARRAY_EXP, "urBindlessImagesMapExternalArrayExp", ¶ms); - getContext()->logger.info("---> urBindlessImagesMapExternalArrayExp"); + auto &logger = getContext()->logger; + + logger.info("---> urBindlessImagesMapExternalArrayExp"); ur_result_t result = pfnMapExternalArrayExp( hContext, hDevice, pImageFormat, pImageDesc, hExternalMem, phImageMem); @@ -6042,10 +6635,13 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesMapExternalArrayExp( "urBindlessImagesMapExternalArrayExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_BINDLESS_IMAGES_MAP_EXTERNAL_ARRAY_EXP, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_BINDLESS_IMAGES_MAP_EXTERNAL_ARRAY_EXP, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -6075,8 +6671,9 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesMapExternalLinearMemoryExp( UR_FUNCTION_BINDLESS_IMAGES_MAP_EXTERNAL_LINEAR_MEMORY_EXP, "urBindlessImagesMapExternalLinearMemoryExp", ¶ms); - getContext()->logger.info( - "---> urBindlessImagesMapExternalLinearMemoryExp"); + auto &logger = getContext()->logger; + + logger.info("---> urBindlessImagesMapExternalLinearMemoryExp"); ur_result_t result = pfnMapExternalLinearMemoryExp( hContext, hDevice, offset, size, hExternalMem, ppRetMem); @@ -6086,11 +6683,14 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesMapExternalLinearMemoryExp( "urBindlessImagesMapExternalLinearMemoryExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_BINDLESS_IMAGES_MAP_EXTERNAL_LINEAR_MEMORY_EXP, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, + UR_FUNCTION_BINDLESS_IMAGES_MAP_EXTERNAL_LINEAR_MEMORY_EXP, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -6116,7 +6716,9 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesReleaseExternalMemoryExp( UR_FUNCTION_BINDLESS_IMAGES_RELEASE_EXTERNAL_MEMORY_EXP, "urBindlessImagesReleaseExternalMemoryExp", ¶ms); - getContext()->logger.info("---> urBindlessImagesReleaseExternalMemoryExp"); + auto &logger = getContext()->logger; + + logger.info("---> urBindlessImagesReleaseExternalMemoryExp"); ur_result_t result = pfnReleaseExternalMemoryExp(hContext, hDevice, hExternalMem); @@ -6125,11 +6727,13 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesReleaseExternalMemoryExp( UR_FUNCTION_BINDLESS_IMAGES_RELEASE_EXTERNAL_MEMORY_EXP, "urBindlessImagesReleaseExternalMemoryExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_BINDLESS_IMAGES_RELEASE_EXTERNAL_MEMORY_EXP, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_BINDLESS_IMAGES_RELEASE_EXTERNAL_MEMORY_EXP, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -6161,8 +6765,9 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesImportExternalSemaphoreExp( UR_FUNCTION_BINDLESS_IMAGES_IMPORT_EXTERNAL_SEMAPHORE_EXP, "urBindlessImagesImportExternalSemaphoreExp", ¶ms); - getContext()->logger.info( - "---> urBindlessImagesImportExternalSemaphoreExp"); + auto &logger = getContext()->logger; + + logger.info("---> urBindlessImagesImportExternalSemaphoreExp"); ur_result_t result = pfnImportExternalSemaphoreExp( hContext, hDevice, semHandleType, pExternalSemaphoreDesc, @@ -6173,11 +6778,13 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesImportExternalSemaphoreExp( "urBindlessImagesImportExternalSemaphoreExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_BINDLESS_IMAGES_IMPORT_EXTERNAL_SEMAPHORE_EXP, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_BINDLESS_IMAGES_IMPORT_EXTERNAL_SEMAPHORE_EXP, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -6204,8 +6811,9 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesReleaseExternalSemaphoreExp( UR_FUNCTION_BINDLESS_IMAGES_RELEASE_EXTERNAL_SEMAPHORE_EXP, "urBindlessImagesReleaseExternalSemaphoreExp", ¶ms); - getContext()->logger.info( - "---> urBindlessImagesReleaseExternalSemaphoreExp"); + auto &logger = getContext()->logger; + + logger.info("---> urBindlessImagesReleaseExternalSemaphoreExp"); ur_result_t result = pfnReleaseExternalSemaphoreExp(hContext, hDevice, hExternalSemaphore); @@ -6215,11 +6823,14 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesReleaseExternalSemaphoreExp( "urBindlessImagesReleaseExternalSemaphoreExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_BINDLESS_IMAGES_RELEASE_EXTERNAL_SEMAPHORE_EXP, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, + UR_FUNCTION_BINDLESS_IMAGES_RELEASE_EXTERNAL_SEMAPHORE_EXP, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -6262,7 +6873,9 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesWaitExternalSemaphoreExp( UR_FUNCTION_BINDLESS_IMAGES_WAIT_EXTERNAL_SEMAPHORE_EXP, "urBindlessImagesWaitExternalSemaphoreExp", ¶ms); - getContext()->logger.info("---> urBindlessImagesWaitExternalSemaphoreExp"); + auto &logger = getContext()->logger; + + logger.info("---> urBindlessImagesWaitExternalSemaphoreExp"); ur_result_t result = pfnWaitExternalSemaphoreExp( hQueue, hSemaphore, hasWaitValue, waitValue, numEventsInWaitList, @@ -6272,11 +6885,13 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesWaitExternalSemaphoreExp( UR_FUNCTION_BINDLESS_IMAGES_WAIT_EXTERNAL_SEMAPHORE_EXP, "urBindlessImagesWaitExternalSemaphoreExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_BINDLESS_IMAGES_WAIT_EXTERNAL_SEMAPHORE_EXP, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_BINDLESS_IMAGES_WAIT_EXTERNAL_SEMAPHORE_EXP, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -6320,8 +6935,9 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesSignalExternalSemaphoreExp( UR_FUNCTION_BINDLESS_IMAGES_SIGNAL_EXTERNAL_SEMAPHORE_EXP, "urBindlessImagesSignalExternalSemaphoreExp", ¶ms); - getContext()->logger.info( - "---> urBindlessImagesSignalExternalSemaphoreExp"); + auto &logger = getContext()->logger; + + logger.info("---> urBindlessImagesSignalExternalSemaphoreExp"); ur_result_t result = pfnSignalExternalSemaphoreExp( hQueue, hSemaphore, hasSignalValue, signalValue, numEventsInWaitList, @@ -6332,11 +6948,13 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesSignalExternalSemaphoreExp( "urBindlessImagesSignalExternalSemaphoreExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_BINDLESS_IMAGES_SIGNAL_EXTERNAL_SEMAPHORE_EXP, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_BINDLESS_IMAGES_SIGNAL_EXTERNAL_SEMAPHORE_EXP, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -6363,7 +6981,9 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferCreateExp( getContext()->notify_begin(UR_FUNCTION_COMMAND_BUFFER_CREATE_EXP, "urCommandBufferCreateExp", ¶ms); - getContext()->logger.info("---> urCommandBufferCreateExp"); + auto &logger = getContext()->logger; + + logger.info("---> urCommandBufferCreateExp"); ur_result_t result = pfnCreateExp(hContext, hDevice, pCommandBufferDesc, phCommandBuffer); @@ -6372,10 +6992,12 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferCreateExp( "urCommandBufferCreateExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_COMMAND_BUFFER_CREATE_EXP, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_COMMAND_BUFFER_CREATE_EXP, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -6397,7 +7019,9 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferRetainExp( getContext()->notify_begin(UR_FUNCTION_COMMAND_BUFFER_RETAIN_EXP, "urCommandBufferRetainExp", ¶ms); - getContext()->logger.info("---> urCommandBufferRetainExp"); + auto &logger = getContext()->logger; + + logger.info("---> urCommandBufferRetainExp"); ur_result_t result = pfnRetainExp(hCommandBuffer); @@ -6405,10 +7029,12 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferRetainExp( "urCommandBufferRetainExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_COMMAND_BUFFER_RETAIN_EXP, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_COMMAND_BUFFER_RETAIN_EXP, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -6431,7 +7057,9 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferReleaseExp( getContext()->notify_begin(UR_FUNCTION_COMMAND_BUFFER_RELEASE_EXP, "urCommandBufferReleaseExp", ¶ms); - getContext()->logger.info("---> urCommandBufferReleaseExp"); + auto &logger = getContext()->logger; + + logger.info("---> urCommandBufferReleaseExp"); ur_result_t result = pfnReleaseExp(hCommandBuffer); @@ -6439,10 +7067,12 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferReleaseExp( "urCommandBufferReleaseExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_COMMAND_BUFFER_RELEASE_EXP, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_COMMAND_BUFFER_RELEASE_EXP, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -6465,7 +7095,9 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferFinalizeExp( getContext()->notify_begin(UR_FUNCTION_COMMAND_BUFFER_FINALIZE_EXP, "urCommandBufferFinalizeExp", ¶ms); - getContext()->logger.info("---> urCommandBufferFinalizeExp"); + auto &logger = getContext()->logger; + + logger.info("---> urCommandBufferFinalizeExp"); ur_result_t result = pfnFinalizeExp(hCommandBuffer); @@ -6473,10 +7105,12 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferFinalizeExp( "urCommandBufferFinalizeExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_COMMAND_BUFFER_FINALIZE_EXP, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_COMMAND_BUFFER_FINALIZE_EXP, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -6526,7 +7160,9 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferAppendKernelLaunchExp( UR_FUNCTION_COMMAND_BUFFER_APPEND_KERNEL_LAUNCH_EXP, "urCommandBufferAppendKernelLaunchExp", ¶ms); - getContext()->logger.info("---> urCommandBufferAppendKernelLaunchExp"); + auto &logger = getContext()->logger; + + logger.info("---> urCommandBufferAppendKernelLaunchExp"); ur_result_t result = pfnAppendKernelLaunchExp( hCommandBuffer, hKernel, workDim, pGlobalWorkOffset, pGlobalWorkSize, @@ -6537,10 +7173,13 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferAppendKernelLaunchExp( UR_FUNCTION_COMMAND_BUFFER_APPEND_KERNEL_LAUNCH_EXP, "urCommandBufferAppendKernelLaunchExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_COMMAND_BUFFER_APPEND_KERNEL_LAUNCH_EXP, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_COMMAND_BUFFER_APPEND_KERNEL_LAUNCH_EXP, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -6575,7 +7214,9 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferAppendUSMMemcpyExp( UR_FUNCTION_COMMAND_BUFFER_APPEND_USM_MEMCPY_EXP, "urCommandBufferAppendUSMMemcpyExp", ¶ms); - getContext()->logger.info("---> urCommandBufferAppendUSMMemcpyExp"); + auto &logger = getContext()->logger; + + logger.info("---> urCommandBufferAppendUSMMemcpyExp"); ur_result_t result = pfnAppendUSMMemcpyExp(hCommandBuffer, pDst, pSrc, size, numSyncPointsInWaitList, @@ -6585,10 +7226,13 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferAppendUSMMemcpyExp( "urCommandBufferAppendUSMMemcpyExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_COMMAND_BUFFER_APPEND_USM_MEMCPY_EXP, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_COMMAND_BUFFER_APPEND_USM_MEMCPY_EXP, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -6626,7 +7270,9 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferAppendUSMFillExp( UR_FUNCTION_COMMAND_BUFFER_APPEND_USM_FILL_EXP, "urCommandBufferAppendUSMFillExp", ¶ms); - getContext()->logger.info("---> urCommandBufferAppendUSMFillExp"); + auto &logger = getContext()->logger; + + logger.info("---> urCommandBufferAppendUSMFillExp"); ur_result_t result = pfnAppendUSMFillExp( hCommandBuffer, pMemory, pPattern, patternSize, size, @@ -6636,10 +7282,12 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferAppendUSMFillExp( "urCommandBufferAppendUSMFillExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_COMMAND_BUFFER_APPEND_USM_FILL_EXP, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_COMMAND_BUFFER_APPEND_USM_FILL_EXP, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -6683,7 +7331,9 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferAppendMemBufferCopyExp( UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_COPY_EXP, "urCommandBufferAppendMemBufferCopyExp", ¶ms); - getContext()->logger.info("---> urCommandBufferAppendMemBufferCopyExp"); + auto &logger = getContext()->logger; + + logger.info("---> urCommandBufferAppendMemBufferCopyExp"); ur_result_t result = pfnAppendMemBufferCopyExp( hCommandBuffer, hSrcMem, hDstMem, srcOffset, dstOffset, size, @@ -6693,11 +7343,13 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferAppendMemBufferCopyExp( UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_COPY_EXP, "urCommandBufferAppendMemBufferCopyExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_COPY_EXP, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_COPY_EXP, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -6740,7 +7392,9 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferAppendMemBufferWriteExp( UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_WRITE_EXP, "urCommandBufferAppendMemBufferWriteExp", ¶ms); - getContext()->logger.info("---> urCommandBufferAppendMemBufferWriteExp"); + auto &logger = getContext()->logger; + + logger.info("---> urCommandBufferAppendMemBufferWriteExp"); ur_result_t result = pfnAppendMemBufferWriteExp( hCommandBuffer, hBuffer, offset, size, pSrc, numSyncPointsInWaitList, @@ -6750,11 +7404,13 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferAppendMemBufferWriteExp( UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_WRITE_EXP, "urCommandBufferAppendMemBufferWriteExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_WRITE_EXP, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_WRITE_EXP, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -6796,7 +7452,9 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferAppendMemBufferReadExp( UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_READ_EXP, "urCommandBufferAppendMemBufferReadExp", ¶ms); - getContext()->logger.info("---> urCommandBufferAppendMemBufferReadExp"); + auto &logger = getContext()->logger; + + logger.info("---> urCommandBufferAppendMemBufferReadExp"); ur_result_t result = pfnAppendMemBufferReadExp( hCommandBuffer, hBuffer, offset, size, pDst, numSyncPointsInWaitList, @@ -6806,11 +7464,13 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferAppendMemBufferReadExp( UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_READ_EXP, "urCommandBufferAppendMemBufferReadExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_READ_EXP, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_READ_EXP, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -6865,7 +7525,9 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferAppendMemBufferCopyRectExp( UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_COPY_RECT_EXP, "urCommandBufferAppendMemBufferCopyRectExp", ¶ms); - getContext()->logger.info("---> urCommandBufferAppendMemBufferCopyRectExp"); + auto &logger = getContext()->logger; + + logger.info("---> urCommandBufferAppendMemBufferCopyRectExp"); ur_result_t result = pfnAppendMemBufferCopyRectExp( hCommandBuffer, hSrcMem, hDstMem, srcOrigin, dstOrigin, region, @@ -6877,11 +7539,14 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferAppendMemBufferCopyRectExp( "urCommandBufferAppendMemBufferCopyRectExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_COPY_RECT_EXP, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, + UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_COPY_RECT_EXP, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -6943,8 +7608,9 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferAppendMemBufferWriteRectExp( UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_WRITE_RECT_EXP, "urCommandBufferAppendMemBufferWriteRectExp", ¶ms); - getContext()->logger.info( - "---> urCommandBufferAppendMemBufferWriteRectExp"); + auto &logger = getContext()->logger; + + logger.info("---> urCommandBufferAppendMemBufferWriteRectExp"); ur_result_t result = pfnAppendMemBufferWriteRectExp( hCommandBuffer, hBuffer, bufferOffset, hostOffset, region, @@ -6956,11 +7622,14 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferAppendMemBufferWriteRectExp( "urCommandBufferAppendMemBufferWriteRectExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_WRITE_RECT_EXP, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, + UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_WRITE_RECT_EXP, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -7019,7 +7688,9 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferAppendMemBufferReadRectExp( UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_READ_RECT_EXP, "urCommandBufferAppendMemBufferReadRectExp", ¶ms); - getContext()->logger.info("---> urCommandBufferAppendMemBufferReadRectExp"); + auto &logger = getContext()->logger; + + logger.info("---> urCommandBufferAppendMemBufferReadRectExp"); ur_result_t result = pfnAppendMemBufferReadRectExp( hCommandBuffer, hBuffer, bufferOffset, hostOffset, region, @@ -7031,11 +7702,14 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferAppendMemBufferReadRectExp( "urCommandBufferAppendMemBufferReadRectExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_READ_RECT_EXP, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, + UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_READ_RECT_EXP, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -7080,7 +7754,9 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferAppendMemBufferFillExp( UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_FILL_EXP, "urCommandBufferAppendMemBufferFillExp", ¶ms); - getContext()->logger.info("---> urCommandBufferAppendMemBufferFillExp"); + auto &logger = getContext()->logger; + + logger.info("---> urCommandBufferAppendMemBufferFillExp"); ur_result_t result = pfnAppendMemBufferFillExp( hCommandBuffer, hBuffer, pPattern, patternSize, offset, size, @@ -7090,11 +7766,13 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferAppendMemBufferFillExp( UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_FILL_EXP, "urCommandBufferAppendMemBufferFillExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_FILL_EXP, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_FILL_EXP, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -7134,7 +7812,9 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferAppendUSMPrefetchExp( UR_FUNCTION_COMMAND_BUFFER_APPEND_USM_PREFETCH_EXP, "urCommandBufferAppendUSMPrefetchExp", ¶ms); - getContext()->logger.info("---> urCommandBufferAppendUSMPrefetchExp"); + auto &logger = getContext()->logger; + + logger.info("---> urCommandBufferAppendUSMPrefetchExp"); ur_result_t result = pfnAppendUSMPrefetchExp( hCommandBuffer, pMemory, size, flags, numSyncPointsInWaitList, @@ -7144,10 +7824,13 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferAppendUSMPrefetchExp( "urCommandBufferAppendUSMPrefetchExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_COMMAND_BUFFER_APPEND_USM_PREFETCH_EXP, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_COMMAND_BUFFER_APPEND_USM_PREFETCH_EXP, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -7187,7 +7870,9 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferAppendUSMAdviseExp( UR_FUNCTION_COMMAND_BUFFER_APPEND_USM_ADVISE_EXP, "urCommandBufferAppendUSMAdviseExp", ¶ms); - getContext()->logger.info("---> urCommandBufferAppendUSMAdviseExp"); + auto &logger = getContext()->logger; + + logger.info("---> urCommandBufferAppendUSMAdviseExp"); ur_result_t result = pfnAppendUSMAdviseExp(hCommandBuffer, pMemory, size, advice, numSyncPointsInWaitList, @@ -7197,10 +7882,13 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferAppendUSMAdviseExp( "urCommandBufferAppendUSMAdviseExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_COMMAND_BUFFER_APPEND_USM_ADVISE_EXP, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_COMMAND_BUFFER_APPEND_USM_ADVISE_EXP, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -7235,7 +7923,9 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferEnqueueExp( getContext()->notify_begin(UR_FUNCTION_COMMAND_BUFFER_ENQUEUE_EXP, "urCommandBufferEnqueueExp", ¶ms); - getContext()->logger.info("---> urCommandBufferEnqueueExp"); + auto &logger = getContext()->logger; + + logger.info("---> urCommandBufferEnqueueExp"); ur_result_t result = pfnEnqueueExp( hCommandBuffer, hQueue, numEventsInWaitList, phEventWaitList, phEvent); @@ -7244,10 +7934,12 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferEnqueueExp( "urCommandBufferEnqueueExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_COMMAND_BUFFER_ENQUEUE_EXP, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_COMMAND_BUFFER_ENQUEUE_EXP, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -7270,7 +7962,9 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferRetainCommandExp( UR_FUNCTION_COMMAND_BUFFER_RETAIN_COMMAND_EXP, "urCommandBufferRetainCommandExp", ¶ms); - getContext()->logger.info("---> urCommandBufferRetainCommandExp"); + auto &logger = getContext()->logger; + + logger.info("---> urCommandBufferRetainCommandExp"); ur_result_t result = pfnRetainCommandExp(hCommand); @@ -7278,10 +7972,12 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferRetainCommandExp( "urCommandBufferRetainCommandExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_COMMAND_BUFFER_RETAIN_COMMAND_EXP, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_COMMAND_BUFFER_RETAIN_COMMAND_EXP, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -7304,7 +8000,9 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferReleaseCommandExp( UR_FUNCTION_COMMAND_BUFFER_RELEASE_COMMAND_EXP, "urCommandBufferReleaseCommandExp", ¶ms); - getContext()->logger.info("---> urCommandBufferReleaseCommandExp"); + auto &logger = getContext()->logger; + + logger.info("---> urCommandBufferReleaseCommandExp"); ur_result_t result = pfnReleaseCommandExp(hCommand); @@ -7312,10 +8010,12 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferReleaseCommandExp( "urCommandBufferReleaseCommandExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_COMMAND_BUFFER_RELEASE_COMMAND_EXP, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_COMMAND_BUFFER_RELEASE_COMMAND_EXP, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -7341,7 +8041,9 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferUpdateKernelLaunchExp( UR_FUNCTION_COMMAND_BUFFER_UPDATE_KERNEL_LAUNCH_EXP, "urCommandBufferUpdateKernelLaunchExp", ¶ms); - getContext()->logger.info("---> urCommandBufferUpdateKernelLaunchExp"); + auto &logger = getContext()->logger; + + logger.info("---> urCommandBufferUpdateKernelLaunchExp"); ur_result_t result = pfnUpdateKernelLaunchExp(hCommand, pUpdateKernelLaunch); @@ -7350,10 +8052,13 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferUpdateKernelLaunchExp( UR_FUNCTION_COMMAND_BUFFER_UPDATE_KERNEL_LAUNCH_EXP, "urCommandBufferUpdateKernelLaunchExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_COMMAND_BUFFER_UPDATE_KERNEL_LAUNCH_EXP, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_COMMAND_BUFFER_UPDATE_KERNEL_LAUNCH_EXP, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -7386,7 +8091,9 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferGetInfoExp( getContext()->notify_begin(UR_FUNCTION_COMMAND_BUFFER_GET_INFO_EXP, "urCommandBufferGetInfoExp", ¶ms); - getContext()->logger.info("---> urCommandBufferGetInfoExp"); + auto &logger = getContext()->logger; + + logger.info("---> urCommandBufferGetInfoExp"); ur_result_t result = pfnGetInfoExp(hCommandBuffer, propName, propSize, pPropValue, pPropSizeRet); @@ -7395,10 +8102,12 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferGetInfoExp( "urCommandBufferGetInfoExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_COMMAND_BUFFER_GET_INFO_EXP, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_COMMAND_BUFFER_GET_INFO_EXP, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -7431,7 +8140,9 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferCommandGetInfoExp( UR_FUNCTION_COMMAND_BUFFER_COMMAND_GET_INFO_EXP, "urCommandBufferCommandGetInfoExp", ¶ms); - getContext()->logger.info("---> urCommandBufferCommandGetInfoExp"); + auto &logger = getContext()->logger; + + logger.info("---> urCommandBufferCommandGetInfoExp"); ur_result_t result = pfnCommandGetInfoExp(hCommand, propName, propSize, pPropValue, pPropSizeRet); @@ -7440,10 +8151,12 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferCommandGetInfoExp( "urCommandBufferCommandGetInfoExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_COMMAND_BUFFER_COMMAND_GET_INFO_EXP, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_COMMAND_BUFFER_COMMAND_GET_INFO_EXP, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -7500,7 +8213,9 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueCooperativeKernelLaunchExp( UR_FUNCTION_ENQUEUE_COOPERATIVE_KERNEL_LAUNCH_EXP, "urEnqueueCooperativeKernelLaunchExp", ¶ms); - getContext()->logger.info("---> urEnqueueCooperativeKernelLaunchExp"); + auto &logger = getContext()->logger; + + logger.info("---> urEnqueueCooperativeKernelLaunchExp"); ur_result_t result = pfnCooperativeKernelLaunchExp( hQueue, hKernel, workDim, pGlobalWorkOffset, pGlobalWorkSize, @@ -7510,10 +8225,13 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueCooperativeKernelLaunchExp( "urEnqueueCooperativeKernelLaunchExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ENQUEUE_COOPERATIVE_KERNEL_LAUNCH_EXP, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_ENQUEUE_COOPERATIVE_KERNEL_LAUNCH_EXP, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -7544,8 +8262,9 @@ __urdlllocal ur_result_t UR_APICALL urKernelSuggestMaxCooperativeGroupCountExp( UR_FUNCTION_KERNEL_SUGGEST_MAX_COOPERATIVE_GROUP_COUNT_EXP, "urKernelSuggestMaxCooperativeGroupCountExp", ¶ms); - getContext()->logger.info( - "---> urKernelSuggestMaxCooperativeGroupCountExp"); + auto &logger = getContext()->logger; + + logger.info("---> urKernelSuggestMaxCooperativeGroupCountExp"); ur_result_t result = pfnSuggestMaxCooperativeGroupCountExp( hKernel, localWorkSize, dynamicSharedMemorySize, pGroupCountRet); @@ -7555,11 +8274,14 @@ __urdlllocal ur_result_t UR_APICALL urKernelSuggestMaxCooperativeGroupCountExp( "urKernelSuggestMaxCooperativeGroupCountExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_KERNEL_SUGGEST_MAX_COOPERATIVE_GROUP_COUNT_EXP, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, + UR_FUNCTION_KERNEL_SUGGEST_MAX_COOPERATIVE_GROUP_COUNT_EXP, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -7600,7 +8322,9 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueTimestampRecordingExp( getContext()->notify_begin(UR_FUNCTION_ENQUEUE_TIMESTAMP_RECORDING_EXP, "urEnqueueTimestampRecordingExp", ¶ms); - getContext()->logger.info("---> urEnqueueTimestampRecordingExp"); + auto &logger = getContext()->logger; + + logger.info("---> urEnqueueTimestampRecordingExp"); ur_result_t result = pfnTimestampRecordingExp( hQueue, blocking, numEventsInWaitList, phEventWaitList, phEvent); @@ -7609,10 +8333,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueTimestampRecordingExp( "urEnqueueTimestampRecordingExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ENQUEUE_TIMESTAMP_RECORDING_EXP, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_ENQUEUE_TIMESTAMP_RECORDING_EXP, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -7664,7 +8390,9 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueKernelLaunchCustomExp( getContext()->notify_begin(UR_FUNCTION_ENQUEUE_KERNEL_LAUNCH_CUSTOM_EXP, "urEnqueueKernelLaunchCustomExp", ¶ms); - getContext()->logger.info("---> urEnqueueKernelLaunchCustomExp"); + auto &logger = getContext()->logger; + + logger.info("---> urEnqueueKernelLaunchCustomExp"); ur_result_t result = pfnKernelLaunchCustomExp( hQueue, hKernel, workDim, pGlobalWorkSize, pLocalWorkSize, @@ -7675,10 +8403,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueKernelLaunchCustomExp( "urEnqueueKernelLaunchCustomExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ENQUEUE_KERNEL_LAUNCH_CUSTOM_EXP, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_ENQUEUE_KERNEL_LAUNCH_CUSTOM_EXP, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -7704,17 +8434,21 @@ __urdlllocal ur_result_t UR_APICALL urProgramBuildExp( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_PROGRAM_BUILD_EXP, "urProgramBuildExp", ¶ms); - getContext()->logger.info("---> urProgramBuildExp"); + auto &logger = getContext()->logger; + + logger.info("---> urProgramBuildExp"); ur_result_t result = pfnBuildExp(hProgram, numDevices, phDevices, pOptions); getContext()->notify_end(UR_FUNCTION_PROGRAM_BUILD_EXP, "urProgramBuildExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_PROGRAM_BUILD_EXP, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_PROGRAM_BUILD_EXP, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -7741,7 +8475,9 @@ __urdlllocal ur_result_t UR_APICALL urProgramCompileExp( uint64_t instance = getContext()->notify_begin( UR_FUNCTION_PROGRAM_COMPILE_EXP, "urProgramCompileExp", ¶ms); - getContext()->logger.info("---> urProgramCompileExp"); + auto &logger = getContext()->logger; + + logger.info("---> urProgramCompileExp"); ur_result_t result = pfnCompileExp(hProgram, numDevices, phDevices, pOptions); @@ -7749,10 +8485,12 @@ __urdlllocal ur_result_t UR_APICALL urProgramCompileExp( getContext()->notify_end(UR_FUNCTION_PROGRAM_COMPILE_EXP, "urProgramCompileExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_PROGRAM_COMPILE_EXP, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_PROGRAM_COMPILE_EXP, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -7787,7 +8525,9 @@ __urdlllocal ur_result_t UR_APICALL urProgramLinkExp( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_PROGRAM_LINK_EXP, "urProgramLinkExp", ¶ms); - getContext()->logger.info("---> urProgramLinkExp"); + auto &logger = getContext()->logger; + + logger.info("---> urProgramLinkExp"); ur_result_t result = pfnLinkExp(hContext, numDevices, phDevices, count, phPrograms, pOptions, phProgram); @@ -7795,10 +8535,12 @@ __urdlllocal ur_result_t UR_APICALL urProgramLinkExp( getContext()->notify_end(UR_FUNCTION_PROGRAM_LINK_EXP, "urProgramLinkExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_PROGRAM_LINK_EXP, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_PROGRAM_LINK_EXP, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -7820,17 +8562,21 @@ __urdlllocal ur_result_t UR_APICALL urUSMImportExp( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_USM_IMPORT_EXP, "urUSMImportExp", ¶ms); - getContext()->logger.info("---> urUSMImportExp"); + auto &logger = getContext()->logger; + + logger.info("---> urUSMImportExp"); ur_result_t result = pfnImportExp(hContext, pMem, size); getContext()->notify_end(UR_FUNCTION_USM_IMPORT_EXP, "urUSMImportExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_USM_IMPORT_EXP, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_USM_IMPORT_EXP, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -7851,17 +8597,21 @@ __urdlllocal ur_result_t UR_APICALL urUSMReleaseExp( uint64_t instance = getContext()->notify_begin(UR_FUNCTION_USM_RELEASE_EXP, "urUSMReleaseExp", ¶ms); - getContext()->logger.info("---> urUSMReleaseExp"); + auto &logger = getContext()->logger; + + logger.info("---> urUSMReleaseExp"); ur_result_t result = pfnReleaseExp(hContext, pMem); getContext()->notify_end(UR_FUNCTION_USM_RELEASE_EXP, "urUSMReleaseExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_USM_RELEASE_EXP, - ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams(args_str, UR_FUNCTION_USM_RELEASE_EXP, + ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -7886,7 +8636,9 @@ __urdlllocal ur_result_t UR_APICALL urUsmP2PEnablePeerAccessExp( getContext()->notify_begin(UR_FUNCTION_USM_P2P_ENABLE_PEER_ACCESS_EXP, "urUsmP2PEnablePeerAccessExp", ¶ms); - getContext()->logger.info("---> urUsmP2PEnablePeerAccessExp"); + auto &logger = getContext()->logger; + + logger.info("---> urUsmP2PEnablePeerAccessExp"); ur_result_t result = pfnEnablePeerAccessExp(commandDevice, peerDevice); @@ -7894,10 +8646,12 @@ __urdlllocal ur_result_t UR_APICALL urUsmP2PEnablePeerAccessExp( "urUsmP2PEnablePeerAccessExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_USM_P2P_ENABLE_PEER_ACCESS_EXP, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_USM_P2P_ENABLE_PEER_ACCESS_EXP, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -7922,7 +8676,9 @@ __urdlllocal ur_result_t UR_APICALL urUsmP2PDisablePeerAccessExp( getContext()->notify_begin(UR_FUNCTION_USM_P2P_DISABLE_PEER_ACCESS_EXP, "urUsmP2PDisablePeerAccessExp", ¶ms); - getContext()->logger.info("---> urUsmP2PDisablePeerAccessExp"); + auto &logger = getContext()->logger; + + logger.info("---> urUsmP2PDisablePeerAccessExp"); ur_result_t result = pfnDisablePeerAccessExp(commandDevice, peerDevice); @@ -7930,10 +8686,12 @@ __urdlllocal ur_result_t UR_APICALL urUsmP2PDisablePeerAccessExp( "urUsmP2PDisablePeerAccessExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_USM_P2P_DISABLE_PEER_ACCESS_EXP, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_USM_P2P_DISABLE_PEER_ACCESS_EXP, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -7970,7 +8728,9 @@ __urdlllocal ur_result_t UR_APICALL urUsmP2PPeerAccessGetInfoExp( getContext()->notify_begin(UR_FUNCTION_USM_P2P_PEER_ACCESS_GET_INFO_EXP, "urUsmP2PPeerAccessGetInfoExp", ¶ms); - getContext()->logger.info("---> urUsmP2PPeerAccessGetInfoExp"); + auto &logger = getContext()->logger; + + logger.info("---> urUsmP2PPeerAccessGetInfoExp"); ur_result_t result = pfnPeerAccessGetInfoExp(commandDevice, peerDevice, propName, propSize, @@ -7980,10 +8740,12 @@ __urdlllocal ur_result_t UR_APICALL urUsmP2PPeerAccessGetInfoExp( "urUsmP2PPeerAccessGetInfoExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_USM_P2P_PEER_ACCESS_GET_INFO_EXP, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_USM_P2P_PEER_ACCESS_GET_INFO_EXP, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; } @@ -8033,7 +8795,9 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueNativeCommandExp( getContext()->notify_begin(UR_FUNCTION_ENQUEUE_NATIVE_COMMAND_EXP, "urEnqueueNativeCommandExp", ¶ms); - getContext()->logger.info("---> urEnqueueNativeCommandExp"); + auto &logger = getContext()->logger; + + logger.info("---> urEnqueueNativeCommandExp"); ur_result_t result = pfnNativeCommandExp( hQueue, pfnNativeEnqueue, data, numMemsInMemList, phMemList, @@ -8043,10 +8807,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueNativeCommandExp( "urEnqueueNativeCommandExp", ¶ms, &result, instance); - std::ostringstream args_str; - ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ENQUEUE_NATIVE_COMMAND_EXP, ¶ms); - getContext()->logger.info("({}) -> {};\n", args_str.str(), result); + if (logger.getLevel() <= logger::Level::INFO) { + std::ostringstream args_str; + ur::extras::printFunctionParams( + args_str, UR_FUNCTION_ENQUEUE_NATIVE_COMMAND_EXP, ¶ms); + logger.info("({}) -> {};\n", args_str.str(), result); + } return result; }