From 12e0cee8f7ef2761c1ce8d45312855dc84140ee0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C5=81ukasz=20=C5=9Alusarczyk?= Date: Wed, 18 Sep 2024 11:18:10 +0200 Subject: [PATCH] fixed mixed output of adapter and regular traces Fixed #2002 issue. Regular UR tracing prints now calls in two separate lines like PI does. --- scripts/templates/trcddi.cpp.mako | 15 +- source/loader/layers/tracing/ur_trcddi.cpp | 3539 ++++++++++++----- .../tracing/hello_world.out.logged.match | 30 +- 3 files changed, 2569 insertions(+), 1015 deletions(-) diff --git a/scripts/templates/trcddi.cpp.mako b/scripts/templates/trcddi.cpp.mako index 45a2baad76..a724540a6b 100644 --- a/scripts/templates/trcddi.cpp.mako +++ b/scripts/templates/trcddi.cpp.mako @@ -46,17 +46,22 @@ namespace ur_tracing_layer uint64_t instance = getContext()->notify_begin(${th.make_func_etor(n, tags, obj)}, "${th.make_func_name(n, tags, obj)}", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> ${th.make_func_name(n, tags, obj)}"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, ${th.make_func_etor(n, tags, obj)}, ¶ms); + logger.info(" ---> ${th.make_func_name(n, tags, obj)}({})\n", args_str_before.str()); + } ${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); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, ${th.make_func_etor(n, tags, obj)}, ¶ms); + logger.info(" <--- ${th.make_func_name(n, tags, obj)}({}) -> {};\n", args_str_after.str(), result); } return result; diff --git a/source/loader/layers/tracing/ur_trcddi.cpp b/source/loader/layers/tracing/ur_trcddi.cpp index c6e59174c9..24fe47bf0b 100644 --- a/source/loader/layers/tracing/ur_trcddi.cpp +++ b/source/loader/layers/tracing/ur_trcddi.cpp @@ -41,19 +41,26 @@ __urdlllocal ur_result_t UR_APICALL urAdapterGet( "urAdapterGet", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urAdapterGet"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_ADAPTER_GET, ¶ms); + logger.info(" ---> urAdapterGet({})\n", args_str_before.str()); + } ur_result_t result = pfnAdapterGet(NumEntries, phAdapters, pNumAdapters); getContext()->notify_end(UR_FUNCTION_ADAPTER_GET, "urAdapterGet", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_ADAPTER_GET, + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, UR_FUNCTION_ADAPTER_GET, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + logger.info(" <--- urAdapterGet({}) -> {};\n", args_str_after.str(), + result); } return result; @@ -75,19 +82,26 @@ __urdlllocal ur_result_t UR_APICALL urAdapterRelease( "urAdapterRelease", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urAdapterRelease"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_ADAPTER_RELEASE, ¶ms); + logger.info(" ---> urAdapterRelease({})\n", args_str_before.str()); + } ur_result_t result = pfnAdapterRelease(hAdapter); getContext()->notify_end(UR_FUNCTION_ADAPTER_RELEASE, "urAdapterRelease", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_ADAPTER_RELEASE, ¶ms); + logger.info(" <--- urAdapterRelease({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -109,19 +123,26 @@ __urdlllocal ur_result_t UR_APICALL urAdapterRetain( "urAdapterRetain", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urAdapterRetain"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_ADAPTER_RETAIN, ¶ms); + logger.info(" ---> urAdapterRetain({})\n", args_str_before.str()); + } ur_result_t result = pfnAdapterRetain(hAdapter); getContext()->notify_end(UR_FUNCTION_ADAPTER_RETAIN, "urAdapterRetain", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_ADAPTER_RETAIN, ¶ms); + logger.info(" <--- urAdapterRetain({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -151,8 +172,15 @@ __urdlllocal ur_result_t UR_APICALL urAdapterGetLastError( UR_FUNCTION_ADAPTER_GET_LAST_ERROR, "urAdapterGetLastError", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urAdapterGetLastError"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_ADAPTER_GET_LAST_ERROR, ¶ms); + logger.info(" ---> urAdapterGetLastError({})\n", + args_str_before.str()); + } ur_result_t result = pfnAdapterGetLastError(hAdapter, ppMessage, pError); @@ -160,11 +188,12 @@ __urdlllocal ur_result_t UR_APICALL urAdapterGetLastError( "urAdapterGetLastError", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ADAPTER_GET_LAST_ERROR, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_ADAPTER_GET_LAST_ERROR, ¶ms); + logger.info(" <--- urAdapterGetLastError({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -197,8 +226,14 @@ __urdlllocal ur_result_t UR_APICALL urAdapterGetInfo( "urAdapterGetInfo", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urAdapterGetInfo"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_ADAPTER_GET_INFO, ¶ms); + logger.info(" ---> urAdapterGetInfo({})\n", args_str_before.str()); + } ur_result_t result = pfnAdapterGetInfo(hAdapter, propName, propSize, pPropValue, pPropSizeRet); @@ -206,11 +241,12 @@ __urdlllocal ur_result_t UR_APICALL urAdapterGetInfo( getContext()->notify_end(UR_FUNCTION_ADAPTER_GET_INFO, "urAdapterGetInfo", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_ADAPTER_GET_INFO, ¶ms); + logger.info(" <--- urAdapterGetInfo({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -246,8 +282,14 @@ __urdlllocal ur_result_t UR_APICALL urPlatformGet( "urPlatformGet", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urPlatformGet"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_PLATFORM_GET, ¶ms); + logger.info(" ---> urPlatformGet({})\n", args_str_before.str()); + } ur_result_t result = pfnGet(phAdapters, NumAdapters, NumEntries, phPlatforms, pNumPlatforms); @@ -255,11 +297,12 @@ __urdlllocal ur_result_t UR_APICALL urPlatformGet( getContext()->notify_end(UR_FUNCTION_PLATFORM_GET, "urPlatformGet", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_PLATFORM_GET, ¶ms); + logger.info(" <--- urPlatformGet({}) -> {};\n", args_str_after.str(), + result); } return result; @@ -292,8 +335,14 @@ __urdlllocal ur_result_t UR_APICALL urPlatformGetInfo( UR_FUNCTION_PLATFORM_GET_INFO, "urPlatformGetInfo", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urPlatformGetInfo"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_PLATFORM_GET_INFO, ¶ms); + logger.info(" ---> urPlatformGetInfo({})\n", args_str_before.str()); + } ur_result_t result = pfnGetInfo(hPlatform, propName, propSize, pPropValue, pPropSizeRet); @@ -301,11 +350,12 @@ __urdlllocal ur_result_t UR_APICALL urPlatformGetInfo( getContext()->notify_end(UR_FUNCTION_PLATFORM_GET_INFO, "urPlatformGetInfo", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_PLATFORM_GET_INFO, ¶ms); + logger.info(" <--- urPlatformGetInfo({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -329,8 +379,15 @@ __urdlllocal ur_result_t UR_APICALL urPlatformGetApiVersion( "urPlatformGetApiVersion", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urPlatformGetApiVersion"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_PLATFORM_GET_API_VERSION, ¶ms); + logger.info(" ---> urPlatformGetApiVersion({})\n", + args_str_before.str()); + } ur_result_t result = pfnGetApiVersion(hPlatform, pVersion); @@ -338,11 +395,12 @@ __urdlllocal ur_result_t UR_APICALL urPlatformGetApiVersion( "urPlatformGetApiVersion", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_PLATFORM_GET_API_VERSION, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_PLATFORM_GET_API_VERSION, ¶ms); + logger.info(" <--- urPlatformGetApiVersion({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -369,8 +427,15 @@ __urdlllocal ur_result_t UR_APICALL urPlatformGetNativeHandle( "urPlatformGetNativeHandle", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urPlatformGetNativeHandle"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_PLATFORM_GET_NATIVE_HANDLE, ¶ms); + logger.info(" ---> urPlatformGetNativeHandle({})\n", + args_str_before.str()); + } ur_result_t result = pfnGetNativeHandle(hPlatform, phNativePlatform); @@ -378,11 +443,12 @@ __urdlllocal ur_result_t UR_APICALL urPlatformGetNativeHandle( "urPlatformGetNativeHandle", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_PLATFORM_GET_NATIVE_HANDLE, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_PLATFORM_GET_NATIVE_HANDLE, ¶ms); + logger.info(" <--- urPlatformGetNativeHandle({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -414,8 +480,16 @@ __urdlllocal ur_result_t UR_APICALL urPlatformCreateWithNativeHandle( "urPlatformCreateWithNativeHandle", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urPlatformCreateWithNativeHandle"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_PLATFORM_CREATE_WITH_NATIVE_HANDLE, + ¶ms); + logger.info(" ---> urPlatformCreateWithNativeHandle({})\n", + args_str_before.str()); + } ur_result_t result = pfnCreateWithNativeHandle(hNativePlatform, hAdapter, pProperties, phPlatform); @@ -424,11 +498,13 @@ __urdlllocal ur_result_t UR_APICALL urPlatformCreateWithNativeHandle( "urPlatformCreateWithNativeHandle", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_PLATFORM_CREATE_WITH_NATIVE_HANDLE, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_PLATFORM_CREATE_WITH_NATIVE_HANDLE, + ¶ms); + logger.info(" <--- urPlatformCreateWithNativeHandle({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -458,8 +534,15 @@ __urdlllocal ur_result_t UR_APICALL urPlatformGetBackendOption( "urPlatformGetBackendOption", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urPlatformGetBackendOption"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_PLATFORM_GET_BACKEND_OPTION, ¶ms); + logger.info(" ---> urPlatformGetBackendOption({})\n", + args_str_before.str()); + } ur_result_t result = pfnGetBackendOption(hPlatform, pFrontendOption, ppPlatformOption); @@ -468,11 +551,12 @@ __urdlllocal ur_result_t UR_APICALL urPlatformGetBackendOption( "urPlatformGetBackendOption", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_PLATFORM_GET_BACKEND_OPTION, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_PLATFORM_GET_BACKEND_OPTION, ¶ms); + logger.info(" <--- urPlatformGetBackendOption({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -507,8 +591,14 @@ __urdlllocal ur_result_t UR_APICALL urDeviceGet( "urDeviceGet", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urDeviceGet"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, UR_FUNCTION_DEVICE_GET, + ¶ms); + logger.info(" ---> urDeviceGet({})\n", args_str_before.str()); + } ur_result_t result = pfnGet(hPlatform, DeviceType, NumEntries, phDevices, pNumDevices); @@ -516,11 +606,12 @@ __urdlllocal ur_result_t UR_APICALL urDeviceGet( getContext()->notify_end(UR_FUNCTION_DEVICE_GET, "urDeviceGet", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_DEVICE_GET, + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, UR_FUNCTION_DEVICE_GET, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + logger.info(" <--- urDeviceGet({}) -> {};\n", args_str_after.str(), + result); } return result; @@ -554,8 +645,14 @@ __urdlllocal ur_result_t UR_APICALL urDeviceGetInfo( "urDeviceGetInfo", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urDeviceGetInfo"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_DEVICE_GET_INFO, ¶ms); + logger.info(" ---> urDeviceGetInfo({})\n", args_str_before.str()); + } ur_result_t result = pfnGetInfo(hDevice, propName, propSize, pPropValue, pPropSizeRet); @@ -563,11 +660,12 @@ __urdlllocal ur_result_t UR_APICALL urDeviceGetInfo( getContext()->notify_end(UR_FUNCTION_DEVICE_GET_INFO, "urDeviceGetInfo", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_DEVICE_GET_INFO, ¶ms); + logger.info(" <--- urDeviceGetInfo({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -590,19 +688,26 @@ __urdlllocal ur_result_t UR_APICALL urDeviceRetain( "urDeviceRetain", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urDeviceRetain"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_DEVICE_RETAIN, ¶ms); + logger.info(" ---> urDeviceRetain({})\n", args_str_before.str()); + } ur_result_t result = pfnRetain(hDevice); getContext()->notify_end(UR_FUNCTION_DEVICE_RETAIN, "urDeviceRetain", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_DEVICE_RETAIN, ¶ms); + logger.info(" <--- urDeviceRetain({}) -> {};\n", args_str_after.str(), + result); } return result; @@ -625,19 +730,26 @@ __urdlllocal ur_result_t UR_APICALL urDeviceRelease( "urDeviceRelease", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urDeviceRelease"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_DEVICE_RELEASE, ¶ms); + logger.info(" ---> urDeviceRelease({})\n", args_str_before.str()); + } ur_result_t result = pfnRelease(hDevice); getContext()->notify_end(UR_FUNCTION_DEVICE_RELEASE, "urDeviceRelease", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_DEVICE_RELEASE, ¶ms); + logger.info(" <--- urDeviceRelease({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -670,8 +782,14 @@ __urdlllocal ur_result_t UR_APICALL urDevicePartition( UR_FUNCTION_DEVICE_PARTITION, "urDevicePartition", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urDevicePartition"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_DEVICE_PARTITION, ¶ms); + logger.info(" ---> urDevicePartition({})\n", args_str_before.str()); + } ur_result_t result = pfnPartition(hDevice, pProperties, NumDevices, phSubDevices, pNumDevicesRet); @@ -679,11 +797,12 @@ __urdlllocal ur_result_t UR_APICALL urDevicePartition( getContext()->notify_end(UR_FUNCTION_DEVICE_PARTITION, "urDevicePartition", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_DEVICE_PARTITION, ¶ms); + logger.info(" <--- urDevicePartition({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -715,8 +834,15 @@ __urdlllocal ur_result_t UR_APICALL urDeviceSelectBinary( UR_FUNCTION_DEVICE_SELECT_BINARY, "urDeviceSelectBinary", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urDeviceSelectBinary"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_DEVICE_SELECT_BINARY, ¶ms); + logger.info(" ---> urDeviceSelectBinary({})\n", + args_str_before.str()); + } ur_result_t result = pfnSelectBinary(hDevice, pBinaries, NumBinaries, pSelectedBinary); @@ -725,11 +851,12 @@ __urdlllocal ur_result_t UR_APICALL urDeviceSelectBinary( "urDeviceSelectBinary", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_DEVICE_SELECT_BINARY, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_DEVICE_SELECT_BINARY, ¶ms); + logger.info(" <--- urDeviceSelectBinary({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -755,8 +882,15 @@ __urdlllocal ur_result_t UR_APICALL urDeviceGetNativeHandle( "urDeviceGetNativeHandle", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urDeviceGetNativeHandle"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_DEVICE_GET_NATIVE_HANDLE, ¶ms); + logger.info(" ---> urDeviceGetNativeHandle({})\n", + args_str_before.str()); + } ur_result_t result = pfnGetNativeHandle(hDevice, phNativeDevice); @@ -764,11 +898,12 @@ __urdlllocal ur_result_t UR_APICALL urDeviceGetNativeHandle( "urDeviceGetNativeHandle", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_DEVICE_GET_NATIVE_HANDLE, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_DEVICE_GET_NATIVE_HANDLE, ¶ms); + logger.info(" <--- urDeviceGetNativeHandle({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -800,8 +935,16 @@ __urdlllocal ur_result_t UR_APICALL urDeviceCreateWithNativeHandle( "urDeviceCreateWithNativeHandle", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urDeviceCreateWithNativeHandle"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_DEVICE_CREATE_WITH_NATIVE_HANDLE, + ¶ms); + logger.info(" ---> urDeviceCreateWithNativeHandle({})\n", + args_str_before.str()); + } ur_result_t result = pfnCreateWithNativeHandle(hNativeDevice, hAdapter, pProperties, phDevice); @@ -810,11 +953,13 @@ __urdlllocal ur_result_t UR_APICALL urDeviceCreateWithNativeHandle( "urDeviceCreateWithNativeHandle", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_DEVICE_CREATE_WITH_NATIVE_HANDLE, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_DEVICE_CREATE_WITH_NATIVE_HANDLE, + ¶ms); + logger.info(" <--- urDeviceCreateWithNativeHandle({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -845,8 +990,15 @@ __urdlllocal ur_result_t UR_APICALL urDeviceGetGlobalTimestamps( "urDeviceGetGlobalTimestamps", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urDeviceGetGlobalTimestamps"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_DEVICE_GET_GLOBAL_TIMESTAMPS, ¶ms); + logger.info(" ---> urDeviceGetGlobalTimestamps({})\n", + args_str_before.str()); + } ur_result_t result = pfnGetGlobalTimestamps(hDevice, pDeviceTimestamp, pHostTimestamp); @@ -855,11 +1007,12 @@ __urdlllocal ur_result_t UR_APICALL urDeviceGetGlobalTimestamps( "urDeviceGetGlobalTimestamps", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_DEVICE_GET_GLOBAL_TIMESTAMPS, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_DEVICE_GET_GLOBAL_TIMESTAMPS, ¶ms); + logger.info(" <--- urDeviceGetGlobalTimestamps({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -888,8 +1041,14 @@ __urdlllocal ur_result_t UR_APICALL urContextCreate( "urContextCreate", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urContextCreate"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_CONTEXT_CREATE, ¶ms); + logger.info(" ---> urContextCreate({})\n", args_str_before.str()); + } ur_result_t result = pfnCreate(DeviceCount, phDevices, pProperties, phContext); @@ -897,11 +1056,12 @@ __urdlllocal ur_result_t UR_APICALL urContextCreate( getContext()->notify_end(UR_FUNCTION_CONTEXT_CREATE, "urContextCreate", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_CONTEXT_CREATE, ¶ms); + logger.info(" <--- urContextCreate({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -924,19 +1084,26 @@ __urdlllocal ur_result_t UR_APICALL urContextRetain( "urContextRetain", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urContextRetain"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_CONTEXT_RETAIN, ¶ms); + logger.info(" ---> urContextRetain({})\n", args_str_before.str()); + } ur_result_t result = pfnRetain(hContext); getContext()->notify_end(UR_FUNCTION_CONTEXT_RETAIN, "urContextRetain", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_CONTEXT_RETAIN, ¶ms); + logger.info(" <--- urContextRetain({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -959,19 +1126,26 @@ __urdlllocal ur_result_t UR_APICALL urContextRelease( "urContextRelease", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urContextRelease"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_CONTEXT_RELEASE, ¶ms); + logger.info(" ---> urContextRelease({})\n", args_str_before.str()); + } ur_result_t result = pfnRelease(hContext); getContext()->notify_end(UR_FUNCTION_CONTEXT_RELEASE, "urContextRelease", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_CONTEXT_RELEASE, ¶ms); + logger.info(" <--- urContextRelease({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -1006,8 +1180,14 @@ __urdlllocal ur_result_t UR_APICALL urContextGetInfo( "urContextGetInfo", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urContextGetInfo"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_CONTEXT_GET_INFO, ¶ms); + logger.info(" ---> urContextGetInfo({})\n", args_str_before.str()); + } ur_result_t result = pfnGetInfo(hContext, propName, propSize, pPropValue, pPropSizeRet); @@ -1015,11 +1195,12 @@ __urdlllocal ur_result_t UR_APICALL urContextGetInfo( getContext()->notify_end(UR_FUNCTION_CONTEXT_GET_INFO, "urContextGetInfo", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_CONTEXT_GET_INFO, ¶ms); + logger.info(" <--- urContextGetInfo({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -1046,8 +1227,15 @@ __urdlllocal ur_result_t UR_APICALL urContextGetNativeHandle( "urContextGetNativeHandle", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urContextGetNativeHandle"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_CONTEXT_GET_NATIVE_HANDLE, ¶ms); + logger.info(" ---> urContextGetNativeHandle({})\n", + args_str_before.str()); + } ur_result_t result = pfnGetNativeHandle(hContext, phNativeContext); @@ -1055,11 +1243,12 @@ __urdlllocal ur_result_t UR_APICALL urContextGetNativeHandle( "urContextGetNativeHandle", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_CONTEXT_GET_NATIVE_HANDLE, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_CONTEXT_GET_NATIVE_HANDLE, ¶ms); + logger.info(" <--- urContextGetNativeHandle({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -1096,8 +1285,16 @@ __urdlllocal ur_result_t UR_APICALL urContextCreateWithNativeHandle( "urContextCreateWithNativeHandle", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urContextCreateWithNativeHandle"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_CONTEXT_CREATE_WITH_NATIVE_HANDLE, + ¶ms); + logger.info(" ---> urContextCreateWithNativeHandle({})\n", + args_str_before.str()); + } ur_result_t result = pfnCreateWithNativeHandle(hNativeContext, hAdapter, numDevices, @@ -1107,11 +1304,13 @@ __urdlllocal ur_result_t UR_APICALL urContextCreateWithNativeHandle( "urContextCreateWithNativeHandle", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_CONTEXT_CREATE_WITH_NATIVE_HANDLE, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_CONTEXT_CREATE_WITH_NATIVE_HANDLE, + ¶ms); + logger.info(" <--- urContextCreateWithNativeHandle({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -1140,8 +1339,15 @@ __urdlllocal ur_result_t UR_APICALL urContextSetExtendedDeleter( "urContextSetExtendedDeleter", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urContextSetExtendedDeleter"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_CONTEXT_SET_EXTENDED_DELETER, ¶ms); + logger.info(" ---> urContextSetExtendedDeleter({})\n", + args_str_before.str()); + } ur_result_t result = pfnSetExtendedDeleter(hContext, pfnDeleter, pUserData); @@ -1149,11 +1355,12 @@ __urdlllocal ur_result_t UR_APICALL urContextSetExtendedDeleter( "urContextSetExtendedDeleter", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_CONTEXT_SET_EXTENDED_DELETER, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_CONTEXT_SET_EXTENDED_DELETER, ¶ms); + logger.info(" <--- urContextSetExtendedDeleter({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -1182,8 +1389,14 @@ __urdlllocal ur_result_t UR_APICALL urMemImageCreate( "urMemImageCreate", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urMemImageCreate"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_MEM_IMAGE_CREATE, ¶ms); + logger.info(" ---> urMemImageCreate({})\n", args_str_before.str()); + } ur_result_t result = pfnImageCreate(hContext, flags, pImageFormat, pImageDesc, pHost, phMem); @@ -1191,11 +1404,12 @@ __urdlllocal ur_result_t UR_APICALL urMemImageCreate( getContext()->notify_end(UR_FUNCTION_MEM_IMAGE_CREATE, "urMemImageCreate", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_MEM_IMAGE_CREATE, ¶ms); + logger.info(" <--- urMemImageCreate({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -1224,8 +1438,14 @@ __urdlllocal ur_result_t UR_APICALL urMemBufferCreate( UR_FUNCTION_MEM_BUFFER_CREATE, "urMemBufferCreate", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urMemBufferCreate"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_MEM_BUFFER_CREATE, ¶ms); + logger.info(" ---> urMemBufferCreate({})\n", args_str_before.str()); + } ur_result_t result = pfnBufferCreate(hContext, flags, size, pProperties, phBuffer); @@ -1233,11 +1453,12 @@ __urdlllocal ur_result_t UR_APICALL urMemBufferCreate( getContext()->notify_end(UR_FUNCTION_MEM_BUFFER_CREATE, "urMemBufferCreate", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_MEM_BUFFER_CREATE, ¶ms); + logger.info(" <--- urMemBufferCreate({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -1260,19 +1481,26 @@ __urdlllocal ur_result_t UR_APICALL urMemRetain( "urMemRetain", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urMemRetain"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, UR_FUNCTION_MEM_RETAIN, + ¶ms); + logger.info(" ---> urMemRetain({})\n", args_str_before.str()); + } ur_result_t result = pfnRetain(hMem); getContext()->notify_end(UR_FUNCTION_MEM_RETAIN, "urMemRetain", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_MEM_RETAIN, + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, UR_FUNCTION_MEM_RETAIN, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + logger.info(" <--- urMemRetain({}) -> {};\n", args_str_after.str(), + result); } return result; @@ -1295,19 +1523,26 @@ __urdlllocal ur_result_t UR_APICALL urMemRelease( "urMemRelease", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urMemRelease"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_MEM_RELEASE, ¶ms); + logger.info(" ---> urMemRelease({})\n", args_str_before.str()); + } ur_result_t result = pfnRelease(hMem); getContext()->notify_end(UR_FUNCTION_MEM_RELEASE, "urMemRelease", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_MEM_RELEASE, + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, UR_FUNCTION_MEM_RELEASE, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + logger.info(" <--- urMemRelease({}) -> {};\n", args_str_after.str(), + result); } return result; @@ -1337,8 +1572,15 @@ __urdlllocal ur_result_t UR_APICALL urMemBufferPartition( UR_FUNCTION_MEM_BUFFER_PARTITION, "urMemBufferPartition", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urMemBufferPartition"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_MEM_BUFFER_PARTITION, ¶ms); + logger.info(" ---> urMemBufferPartition({})\n", + args_str_before.str()); + } ur_result_t result = pfnBufferPartition(hBuffer, flags, bufferCreateType, pRegion, phMem); @@ -1347,11 +1589,12 @@ __urdlllocal ur_result_t UR_APICALL urMemBufferPartition( "urMemBufferPartition", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_MEM_BUFFER_PARTITION, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_MEM_BUFFER_PARTITION, ¶ms); + logger.info(" <--- urMemBufferPartition({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -1378,8 +1621,15 @@ __urdlllocal ur_result_t UR_APICALL urMemGetNativeHandle( UR_FUNCTION_MEM_GET_NATIVE_HANDLE, "urMemGetNativeHandle", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urMemGetNativeHandle"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_MEM_GET_NATIVE_HANDLE, ¶ms); + logger.info(" ---> urMemGetNativeHandle({})\n", + args_str_before.str()); + } ur_result_t result = pfnGetNativeHandle(hMem, hDevice, phNativeMem); @@ -1387,11 +1637,12 @@ __urdlllocal ur_result_t UR_APICALL urMemGetNativeHandle( "urMemGetNativeHandle", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_MEM_GET_NATIVE_HANDLE, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_MEM_GET_NATIVE_HANDLE, ¶ms); + logger.info(" <--- urMemGetNativeHandle({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -1422,8 +1673,16 @@ __urdlllocal ur_result_t UR_APICALL urMemBufferCreateWithNativeHandle( "urMemBufferCreateWithNativeHandle", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urMemBufferCreateWithNativeHandle"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_MEM_BUFFER_CREATE_WITH_NATIVE_HANDLE, + ¶ms); + logger.info(" ---> urMemBufferCreateWithNativeHandle({})\n", + args_str_before.str()); + } ur_result_t result = pfnBufferCreateWithNativeHandle(hNativeMem, hContext, pProperties, phMem); @@ -1432,12 +1691,13 @@ __urdlllocal ur_result_t UR_APICALL urMemBufferCreateWithNativeHandle( "urMemBufferCreateWithNativeHandle", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_MEM_BUFFER_CREATE_WITH_NATIVE_HANDLE, + args_str_after, UR_FUNCTION_MEM_BUFFER_CREATE_WITH_NATIVE_HANDLE, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + logger.info(" <--- urMemBufferCreateWithNativeHandle({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -1472,8 +1732,16 @@ __urdlllocal ur_result_t UR_APICALL urMemImageCreateWithNativeHandle( "urMemImageCreateWithNativeHandle", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urMemImageCreateWithNativeHandle"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_MEM_IMAGE_CREATE_WITH_NATIVE_HANDLE, + ¶ms); + logger.info(" ---> urMemImageCreateWithNativeHandle({})\n", + args_str_before.str()); + } ur_result_t result = pfnImageCreateWithNativeHandle( hNativeMem, hContext, pImageFormat, pImageDesc, pProperties, phMem); @@ -1482,11 +1750,13 @@ __urdlllocal ur_result_t UR_APICALL urMemImageCreateWithNativeHandle( "urMemImageCreateWithNativeHandle", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_MEM_IMAGE_CREATE_WITH_NATIVE_HANDLE, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_MEM_IMAGE_CREATE_WITH_NATIVE_HANDLE, + ¶ms); + logger.info(" <--- urMemImageCreateWithNativeHandle({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -1521,8 +1791,14 @@ __urdlllocal ur_result_t UR_APICALL urMemGetInfo( "urMemGetInfo", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urMemGetInfo"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_MEM_GET_INFO, ¶ms); + logger.info(" ---> urMemGetInfo({})\n", args_str_before.str()); + } ur_result_t result = pfnGetInfo(hMemory, propName, propSize, pPropValue, pPropSizeRet); @@ -1530,11 +1806,12 @@ __urdlllocal ur_result_t UR_APICALL urMemGetInfo( getContext()->notify_end(UR_FUNCTION_MEM_GET_INFO, "urMemGetInfo", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_MEM_GET_INFO, ¶ms); + logger.info(" <--- urMemGetInfo({}) -> {};\n", args_str_after.str(), + result); } return result; @@ -1568,8 +1845,14 @@ __urdlllocal ur_result_t UR_APICALL urMemImageGetInfo( UR_FUNCTION_MEM_IMAGE_GET_INFO, "urMemImageGetInfo", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urMemImageGetInfo"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_MEM_IMAGE_GET_INFO, ¶ms); + logger.info(" ---> urMemImageGetInfo({})\n", args_str_before.str()); + } ur_result_t result = pfnImageGetInfo(hMemory, propName, propSize, pPropValue, pPropSizeRet); @@ -1577,11 +1860,12 @@ __urdlllocal ur_result_t UR_APICALL urMemImageGetInfo( getContext()->notify_end(UR_FUNCTION_MEM_IMAGE_GET_INFO, "urMemImageGetInfo", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_MEM_IMAGE_GET_INFO, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_MEM_IMAGE_GET_INFO, ¶ms); + logger.info(" <--- urMemImageGetInfo({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -1606,19 +1890,26 @@ __urdlllocal ur_result_t UR_APICALL urSamplerCreate( "urSamplerCreate", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urSamplerCreate"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_SAMPLER_CREATE, ¶ms); + logger.info(" ---> urSamplerCreate({})\n", args_str_before.str()); + } ur_result_t result = pfnCreate(hContext, pDesc, phSampler); getContext()->notify_end(UR_FUNCTION_SAMPLER_CREATE, "urSamplerCreate", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_SAMPLER_CREATE, ¶ms); + logger.info(" <--- urSamplerCreate({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -1641,19 +1932,26 @@ __urdlllocal ur_result_t UR_APICALL urSamplerRetain( "urSamplerRetain", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urSamplerRetain"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_SAMPLER_RETAIN, ¶ms); + logger.info(" ---> urSamplerRetain({})\n", args_str_before.str()); + } ur_result_t result = pfnRetain(hSampler); getContext()->notify_end(UR_FUNCTION_SAMPLER_RETAIN, "urSamplerRetain", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_SAMPLER_RETAIN, ¶ms); + logger.info(" <--- urSamplerRetain({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -1676,19 +1974,26 @@ __urdlllocal ur_result_t UR_APICALL urSamplerRelease( "urSamplerRelease", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urSamplerRelease"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_SAMPLER_RELEASE, ¶ms); + logger.info(" ---> urSamplerRelease({})\n", args_str_before.str()); + } ur_result_t result = pfnRelease(hSampler); getContext()->notify_end(UR_FUNCTION_SAMPLER_RELEASE, "urSamplerRelease", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_SAMPLER_RELEASE, ¶ms); + logger.info(" <--- urSamplerRelease({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -1719,8 +2024,14 @@ __urdlllocal ur_result_t UR_APICALL urSamplerGetInfo( "urSamplerGetInfo", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urSamplerGetInfo"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_SAMPLER_GET_INFO, ¶ms); + logger.info(" ---> urSamplerGetInfo({})\n", args_str_before.str()); + } ur_result_t result = pfnGetInfo(hSampler, propName, propSize, pPropValue, pPropSizeRet); @@ -1728,11 +2039,12 @@ __urdlllocal ur_result_t UR_APICALL urSamplerGetInfo( getContext()->notify_end(UR_FUNCTION_SAMPLER_GET_INFO, "urSamplerGetInfo", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_SAMPLER_GET_INFO, ¶ms); + logger.info(" <--- urSamplerGetInfo({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -1759,8 +2071,15 @@ __urdlllocal ur_result_t UR_APICALL urSamplerGetNativeHandle( "urSamplerGetNativeHandle", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urSamplerGetNativeHandle"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_SAMPLER_GET_NATIVE_HANDLE, ¶ms); + logger.info(" ---> urSamplerGetNativeHandle({})\n", + args_str_before.str()); + } ur_result_t result = pfnGetNativeHandle(hSampler, phNativeSampler); @@ -1768,11 +2087,12 @@ __urdlllocal ur_result_t UR_APICALL urSamplerGetNativeHandle( "urSamplerGetNativeHandle", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_SAMPLER_GET_NATIVE_HANDLE, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_SAMPLER_GET_NATIVE_HANDLE, ¶ms); + logger.info(" <--- urSamplerGetNativeHandle({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -1803,8 +2123,16 @@ __urdlllocal ur_result_t UR_APICALL urSamplerCreateWithNativeHandle( "urSamplerCreateWithNativeHandle", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urSamplerCreateWithNativeHandle"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_SAMPLER_CREATE_WITH_NATIVE_HANDLE, + ¶ms); + logger.info(" ---> urSamplerCreateWithNativeHandle({})\n", + args_str_before.str()); + } ur_result_t result = pfnCreateWithNativeHandle(hNativeSampler, hContext, pProperties, phSampler); @@ -1813,11 +2141,13 @@ __urdlllocal ur_result_t UR_APICALL urSamplerCreateWithNativeHandle( "urSamplerCreateWithNativeHandle", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_SAMPLER_CREATE_WITH_NATIVE_HANDLE, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_SAMPLER_CREATE_WITH_NATIVE_HANDLE, + ¶ms); + logger.info(" <--- urSamplerCreateWithNativeHandle({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -1847,19 +2177,26 @@ __urdlllocal ur_result_t UR_APICALL urUSMHostAlloc( "urUSMHostAlloc", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urUSMHostAlloc"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_USM_HOST_ALLOC, ¶ms); + logger.info(" ---> urUSMHostAlloc({})\n", args_str_before.str()); + } ur_result_t result = pfnHostAlloc(hContext, pUSMDesc, pool, size, ppMem); getContext()->notify_end(UR_FUNCTION_USM_HOST_ALLOC, "urUSMHostAlloc", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_USM_HOST_ALLOC, ¶ms); + logger.info(" <--- urUSMHostAlloc({}) -> {};\n", args_str_after.str(), + result); } return result; @@ -1890,8 +2227,14 @@ __urdlllocal ur_result_t UR_APICALL urUSMDeviceAlloc( "urUSMDeviceAlloc", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urUSMDeviceAlloc"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_USM_DEVICE_ALLOC, ¶ms); + logger.info(" ---> urUSMDeviceAlloc({})\n", args_str_before.str()); + } ur_result_t result = pfnDeviceAlloc(hContext, hDevice, pUSMDesc, pool, size, ppMem); @@ -1899,11 +2242,12 @@ __urdlllocal ur_result_t UR_APICALL urUSMDeviceAlloc( getContext()->notify_end(UR_FUNCTION_USM_DEVICE_ALLOC, "urUSMDeviceAlloc", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_USM_DEVICE_ALLOC, ¶ms); + logger.info(" <--- urUSMDeviceAlloc({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -1934,8 +2278,14 @@ __urdlllocal ur_result_t UR_APICALL urUSMSharedAlloc( "urUSMSharedAlloc", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urUSMSharedAlloc"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_USM_SHARED_ALLOC, ¶ms); + logger.info(" ---> urUSMSharedAlloc({})\n", args_str_before.str()); + } ur_result_t result = pfnSharedAlloc(hContext, hDevice, pUSMDesc, pool, size, ppMem); @@ -1943,11 +2293,12 @@ __urdlllocal ur_result_t UR_APICALL urUSMSharedAlloc( getContext()->notify_end(UR_FUNCTION_USM_SHARED_ALLOC, "urUSMSharedAlloc", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_USM_SHARED_ALLOC, ¶ms); + logger.info(" <--- urUSMSharedAlloc({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -1970,19 +2321,26 @@ __urdlllocal ur_result_t UR_APICALL urUSMFree( getContext()->notify_begin(UR_FUNCTION_USM_FREE, "urUSMFree", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urUSMFree"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, UR_FUNCTION_USM_FREE, + ¶ms); + logger.info(" ---> urUSMFree({})\n", args_str_before.str()); + } ur_result_t result = pfnFree(hContext, pMem); getContext()->notify_end(UR_FUNCTION_USM_FREE, "urUSMFree", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_USM_FREE, + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, UR_FUNCTION_USM_FREE, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + logger.info(" <--- urUSMFree({}) -> {};\n", args_str_after.str(), + result); } return result; @@ -2015,8 +2373,15 @@ __urdlllocal ur_result_t UR_APICALL urUSMGetMemAllocInfo( UR_FUNCTION_USM_GET_MEM_ALLOC_INFO, "urUSMGetMemAllocInfo", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urUSMGetMemAllocInfo"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_USM_GET_MEM_ALLOC_INFO, ¶ms); + logger.info(" ---> urUSMGetMemAllocInfo({})\n", + args_str_before.str()); + } ur_result_t result = pfnGetMemAllocInfo(hContext, pMem, propName, propSize, pPropValue, pPropSizeRet); @@ -2025,11 +2390,12 @@ __urdlllocal ur_result_t UR_APICALL urUSMGetMemAllocInfo( "urUSMGetMemAllocInfo", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_USM_GET_MEM_ALLOC_INFO, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_USM_GET_MEM_ALLOC_INFO, ¶ms); + logger.info(" <--- urUSMGetMemAllocInfo({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -2055,19 +2421,26 @@ __urdlllocal ur_result_t UR_APICALL urUSMPoolCreate( "urUSMPoolCreate", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urUSMPoolCreate"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_USM_POOL_CREATE, ¶ms); + logger.info(" ---> urUSMPoolCreate({})\n", args_str_before.str()); + } ur_result_t result = pfnPoolCreate(hContext, pPoolDesc, ppPool); getContext()->notify_end(UR_FUNCTION_USM_POOL_CREATE, "urUSMPoolCreate", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_USM_POOL_CREATE, ¶ms); + logger.info(" <--- urUSMPoolCreate({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -2089,19 +2462,26 @@ __urdlllocal ur_result_t UR_APICALL urUSMPoolRetain( "urUSMPoolRetain", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urUSMPoolRetain"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_USM_POOL_RETAIN, ¶ms); + logger.info(" ---> urUSMPoolRetain({})\n", args_str_before.str()); + } ur_result_t result = pfnPoolRetain(pPool); getContext()->notify_end(UR_FUNCTION_USM_POOL_RETAIN, "urUSMPoolRetain", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_USM_POOL_RETAIN, ¶ms); + logger.info(" <--- urUSMPoolRetain({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -2123,19 +2503,26 @@ __urdlllocal ur_result_t UR_APICALL urUSMPoolRelease( "urUSMPoolRelease", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urUSMPoolRelease"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_USM_POOL_RELEASE, ¶ms); + logger.info(" ---> urUSMPoolRelease({})\n", args_str_before.str()); + } ur_result_t result = pfnPoolRelease(pPool); getContext()->notify_end(UR_FUNCTION_USM_POOL_RELEASE, "urUSMPoolRelease", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_USM_POOL_RELEASE, ¶ms); + logger.info(" <--- urUSMPoolRelease({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -2165,8 +2552,14 @@ __urdlllocal ur_result_t UR_APICALL urUSMPoolGetInfo( UR_FUNCTION_USM_POOL_GET_INFO, "urUSMPoolGetInfo", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urUSMPoolGetInfo"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_USM_POOL_GET_INFO, ¶ms); + logger.info(" ---> urUSMPoolGetInfo({})\n", args_str_before.str()); + } ur_result_t result = pfnPoolGetInfo(hPool, propName, propSize, pPropValue, pPropSizeRet); @@ -2174,11 +2567,12 @@ __urdlllocal ur_result_t UR_APICALL urUSMPoolGetInfo( getContext()->notify_end(UR_FUNCTION_USM_POOL_GET_INFO, "urUSMPoolGetInfo", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_USM_POOL_GET_INFO, ¶ms); + logger.info(" <--- urUSMPoolGetInfo({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -2217,8 +2611,16 @@ __urdlllocal ur_result_t UR_APICALL urVirtualMemGranularityGetInfo( "urVirtualMemGranularityGetInfo", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urVirtualMemGranularityGetInfo"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_VIRTUAL_MEM_GRANULARITY_GET_INFO, + ¶ms); + logger.info(" ---> urVirtualMemGranularityGetInfo({})\n", + args_str_before.str()); + } ur_result_t result = pfnGranularityGetInfo( hContext, hDevice, propName, propSize, pPropValue, pPropSizeRet); @@ -2227,11 +2629,13 @@ __urdlllocal ur_result_t UR_APICALL urVirtualMemGranularityGetInfo( "urVirtualMemGranularityGetInfo", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_VIRTUAL_MEM_GRANULARITY_GET_INFO, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_VIRTUAL_MEM_GRANULARITY_GET_INFO, + ¶ms); + logger.info(" <--- urVirtualMemGranularityGetInfo({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -2263,19 +2667,26 @@ __urdlllocal ur_result_t UR_APICALL urVirtualMemReserve( UR_FUNCTION_VIRTUAL_MEM_RESERVE, "urVirtualMemReserve", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urVirtualMemReserve"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_VIRTUAL_MEM_RESERVE, ¶ms); + logger.info(" ---> urVirtualMemReserve({})\n", args_str_before.str()); + } ur_result_t result = pfnReserve(hContext, pStart, size, ppStart); getContext()->notify_end(UR_FUNCTION_VIRTUAL_MEM_RESERVE, "urVirtualMemReserve", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_VIRTUAL_MEM_RESERVE, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_VIRTUAL_MEM_RESERVE, ¶ms); + logger.info(" <--- urVirtualMemReserve({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -2300,19 +2711,26 @@ __urdlllocal ur_result_t UR_APICALL urVirtualMemFree( "urVirtualMemFree", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urVirtualMemFree"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_VIRTUAL_MEM_FREE, ¶ms); + logger.info(" ---> urVirtualMemFree({})\n", args_str_before.str()); + } ur_result_t result = pfnFree(hContext, pStart, size); getContext()->notify_end(UR_FUNCTION_VIRTUAL_MEM_FREE, "urVirtualMemFree", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_VIRTUAL_MEM_FREE, ¶ms); + logger.info(" <--- urVirtualMemFree({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -2344,8 +2762,14 @@ __urdlllocal ur_result_t UR_APICALL urVirtualMemMap( "urVirtualMemMap", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urVirtualMemMap"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_VIRTUAL_MEM_MAP, ¶ms); + logger.info(" ---> urVirtualMemMap({})\n", args_str_before.str()); + } ur_result_t result = pfnMap(hContext, pStart, size, hPhysicalMem, offset, flags); @@ -2353,11 +2777,12 @@ __urdlllocal ur_result_t UR_APICALL urVirtualMemMap( getContext()->notify_end(UR_FUNCTION_VIRTUAL_MEM_MAP, "urVirtualMemMap", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_VIRTUAL_MEM_MAP, ¶ms); + logger.info(" <--- urVirtualMemMap({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -2382,19 +2807,26 @@ __urdlllocal ur_result_t UR_APICALL urVirtualMemUnmap( UR_FUNCTION_VIRTUAL_MEM_UNMAP, "urVirtualMemUnmap", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urVirtualMemUnmap"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_VIRTUAL_MEM_UNMAP, ¶ms); + logger.info(" ---> urVirtualMemUnmap({})\n", args_str_before.str()); + } ur_result_t result = pfnUnmap(hContext, pStart, size); getContext()->notify_end(UR_FUNCTION_VIRTUAL_MEM_UNMAP, "urVirtualMemUnmap", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_VIRTUAL_MEM_UNMAP, ¶ms); + logger.info(" <--- urVirtualMemUnmap({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -2422,8 +2854,15 @@ __urdlllocal ur_result_t UR_APICALL urVirtualMemSetAccess( UR_FUNCTION_VIRTUAL_MEM_SET_ACCESS, "urVirtualMemSetAccess", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urVirtualMemSetAccess"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_VIRTUAL_MEM_SET_ACCESS, ¶ms); + logger.info(" ---> urVirtualMemSetAccess({})\n", + args_str_before.str()); + } ur_result_t result = pfnSetAccess(hContext, pStart, size, flags); @@ -2431,11 +2870,12 @@ __urdlllocal ur_result_t UR_APICALL urVirtualMemSetAccess( "urVirtualMemSetAccess", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_VIRTUAL_MEM_SET_ACCESS, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_VIRTUAL_MEM_SET_ACCESS, ¶ms); + logger.info(" <--- urVirtualMemSetAccess({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -2472,8 +2912,14 @@ __urdlllocal ur_result_t UR_APICALL urVirtualMemGetInfo( UR_FUNCTION_VIRTUAL_MEM_GET_INFO, "urVirtualMemGetInfo", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urVirtualMemGetInfo"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_VIRTUAL_MEM_GET_INFO, ¶ms); + logger.info(" ---> urVirtualMemGetInfo({})\n", args_str_before.str()); + } ur_result_t result = pfnGetInfo(hContext, pStart, size, propName, propSize, pPropValue, pPropSizeRet); @@ -2481,11 +2927,12 @@ __urdlllocal ur_result_t UR_APICALL urVirtualMemGetInfo( getContext()->notify_end(UR_FUNCTION_VIRTUAL_MEM_GET_INFO, "urVirtualMemGetInfo", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_VIRTUAL_MEM_GET_INFO, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_VIRTUAL_MEM_GET_INFO, ¶ms); + logger.info(" <--- urVirtualMemGetInfo({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -2516,8 +2963,14 @@ __urdlllocal ur_result_t UR_APICALL urPhysicalMemCreate( UR_FUNCTION_PHYSICAL_MEM_CREATE, "urPhysicalMemCreate", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urPhysicalMemCreate"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_PHYSICAL_MEM_CREATE, ¶ms); + logger.info(" ---> urPhysicalMemCreate({})\n", args_str_before.str()); + } ur_result_t result = pfnCreate(hContext, hDevice, size, pProperties, phPhysicalMem); @@ -2525,11 +2978,12 @@ __urdlllocal ur_result_t UR_APICALL urPhysicalMemCreate( getContext()->notify_end(UR_FUNCTION_PHYSICAL_MEM_CREATE, "urPhysicalMemCreate", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_PHYSICAL_MEM_CREATE, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_PHYSICAL_MEM_CREATE, ¶ms); + logger.info(" <--- urPhysicalMemCreate({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -2552,19 +3006,26 @@ __urdlllocal ur_result_t UR_APICALL urPhysicalMemRetain( UR_FUNCTION_PHYSICAL_MEM_RETAIN, "urPhysicalMemRetain", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urPhysicalMemRetain"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_PHYSICAL_MEM_RETAIN, ¶ms); + logger.info(" ---> urPhysicalMemRetain({})\n", args_str_before.str()); + } ur_result_t result = pfnRetain(hPhysicalMem); getContext()->notify_end(UR_FUNCTION_PHYSICAL_MEM_RETAIN, "urPhysicalMemRetain", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_PHYSICAL_MEM_RETAIN, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_PHYSICAL_MEM_RETAIN, ¶ms); + logger.info(" <--- urPhysicalMemRetain({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -2587,8 +3048,15 @@ __urdlllocal ur_result_t UR_APICALL urPhysicalMemRelease( UR_FUNCTION_PHYSICAL_MEM_RELEASE, "urPhysicalMemRelease", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urPhysicalMemRelease"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_PHYSICAL_MEM_RELEASE, ¶ms); + logger.info(" ---> urPhysicalMemRelease({})\n", + args_str_before.str()); + } ur_result_t result = pfnRelease(hPhysicalMem); @@ -2596,11 +3064,12 @@ __urdlllocal ur_result_t UR_APICALL urPhysicalMemRelease( "urPhysicalMemRelease", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_PHYSICAL_MEM_RELEASE, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_PHYSICAL_MEM_RELEASE, ¶ms); + logger.info(" <--- urPhysicalMemRelease({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -2629,8 +3098,15 @@ __urdlllocal ur_result_t UR_APICALL urProgramCreateWithIL( UR_FUNCTION_PROGRAM_CREATE_WITH_IL, "urProgramCreateWithIL", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urProgramCreateWithIL"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_PROGRAM_CREATE_WITH_IL, ¶ms); + logger.info(" ---> urProgramCreateWithIL({})\n", + args_str_before.str()); + } ur_result_t result = pfnCreateWithIL(hContext, pIL, length, pProperties, phProgram); @@ -2639,11 +3115,12 @@ __urdlllocal ur_result_t UR_APICALL urProgramCreateWithIL( "urProgramCreateWithIL", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_PROGRAM_CREATE_WITH_IL, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_PROGRAM_CREATE_WITH_IL, ¶ms); + logger.info(" <--- urProgramCreateWithIL({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -2676,8 +3153,15 @@ __urdlllocal ur_result_t UR_APICALL urProgramCreateWithBinary( "urProgramCreateWithBinary", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urProgramCreateWithBinary"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_PROGRAM_CREATE_WITH_BINARY, ¶ms); + logger.info(" ---> urProgramCreateWithBinary({})\n", + args_str_before.str()); + } ur_result_t result = pfnCreateWithBinary(hContext, hDevice, size, pBinary, pProperties, phProgram); @@ -2686,11 +3170,12 @@ __urdlllocal ur_result_t UR_APICALL urProgramCreateWithBinary( "urProgramCreateWithBinary", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_PROGRAM_CREATE_WITH_BINARY, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_PROGRAM_CREATE_WITH_BINARY, ¶ms); + logger.info(" <--- urProgramCreateWithBinary({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -2715,19 +3200,26 @@ __urdlllocal ur_result_t UR_APICALL urProgramBuild( "urProgramBuild", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urProgramBuild"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_PROGRAM_BUILD, ¶ms); + logger.info(" ---> urProgramBuild({})\n", args_str_before.str()); + } ur_result_t result = pfnBuild(hContext, hProgram, pOptions); getContext()->notify_end(UR_FUNCTION_PROGRAM_BUILD, "urProgramBuild", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_PROGRAM_BUILD, ¶ms); + logger.info(" <--- urProgramBuild({}) -> {};\n", args_str_after.str(), + result); } return result; @@ -2753,19 +3245,26 @@ __urdlllocal ur_result_t UR_APICALL urProgramCompile( "urProgramCompile", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urProgramCompile"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_PROGRAM_COMPILE, ¶ms); + logger.info(" ---> urProgramCompile({})\n", args_str_before.str()); + } ur_result_t result = pfnCompile(hContext, hProgram, pOptions); getContext()->notify_end(UR_FUNCTION_PROGRAM_COMPILE, "urProgramCompile", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_PROGRAM_COMPILE, ¶ms); + logger.info(" <--- urProgramCompile({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -2798,8 +3297,14 @@ __urdlllocal ur_result_t UR_APICALL urProgramLink( "urProgramLink", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urProgramLink"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_PROGRAM_LINK, ¶ms); + logger.info(" ---> urProgramLink({})\n", args_str_before.str()); + } ur_result_t result = pfnLink(hContext, count, phPrograms, pOptions, phProgram); @@ -2807,11 +3312,12 @@ __urdlllocal ur_result_t UR_APICALL urProgramLink( getContext()->notify_end(UR_FUNCTION_PROGRAM_LINK, "urProgramLink", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_PROGRAM_LINK, ¶ms); + logger.info(" <--- urProgramLink({}) -> {};\n", args_str_after.str(), + result); } return result; @@ -2834,19 +3340,26 @@ __urdlllocal ur_result_t UR_APICALL urProgramRetain( "urProgramRetain", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urProgramRetain"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_PROGRAM_RETAIN, ¶ms); + logger.info(" ---> urProgramRetain({})\n", args_str_before.str()); + } ur_result_t result = pfnRetain(hProgram); getContext()->notify_end(UR_FUNCTION_PROGRAM_RETAIN, "urProgramRetain", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_PROGRAM_RETAIN, ¶ms); + logger.info(" <--- urProgramRetain({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -2869,19 +3382,26 @@ __urdlllocal ur_result_t UR_APICALL urProgramRelease( "urProgramRelease", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urProgramRelease"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_PROGRAM_RELEASE, ¶ms); + logger.info(" ---> urProgramRelease({})\n", args_str_before.str()); + } ur_result_t result = pfnRelease(hProgram); getContext()->notify_end(UR_FUNCTION_PROGRAM_RELEASE, "urProgramRelease", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_PROGRAM_RELEASE, ¶ms); + logger.info(" <--- urProgramRelease({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -2915,8 +3435,15 @@ __urdlllocal ur_result_t UR_APICALL urProgramGetFunctionPointer( "urProgramGetFunctionPointer", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urProgramGetFunctionPointer"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_PROGRAM_GET_FUNCTION_POINTER, ¶ms); + logger.info(" ---> urProgramGetFunctionPointer({})\n", + args_str_before.str()); + } ur_result_t result = pfnGetFunctionPointer(hDevice, hProgram, pFunctionName, ppFunctionPointer); @@ -2925,11 +3452,12 @@ __urdlllocal ur_result_t UR_APICALL urProgramGetFunctionPointer( "urProgramGetFunctionPointer", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_PROGRAM_GET_FUNCTION_POINTER, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_PROGRAM_GET_FUNCTION_POINTER, ¶ms); + logger.info(" <--- urProgramGetFunctionPointer({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -2965,8 +3493,16 @@ __urdlllocal ur_result_t UR_APICALL urProgramGetGlobalVariablePointer( "urProgramGetGlobalVariablePointer", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urProgramGetGlobalVariablePointer"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_PROGRAM_GET_GLOBAL_VARIABLE_POINTER, + ¶ms); + logger.info(" ---> urProgramGetGlobalVariablePointer({})\n", + args_str_before.str()); + } ur_result_t result = pfnGetGlobalVariablePointer( hDevice, hProgram, pGlobalVariableName, pGlobalVariableSizeRet, @@ -2976,11 +3512,13 @@ __urdlllocal ur_result_t UR_APICALL urProgramGetGlobalVariablePointer( "urProgramGetGlobalVariablePointer", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_PROGRAM_GET_GLOBAL_VARIABLE_POINTER, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_PROGRAM_GET_GLOBAL_VARIABLE_POINTER, + ¶ms); + logger.info(" <--- urProgramGetGlobalVariablePointer({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -3014,8 +3552,14 @@ __urdlllocal ur_result_t UR_APICALL urProgramGetInfo( "urProgramGetInfo", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urProgramGetInfo"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_PROGRAM_GET_INFO, ¶ms); + logger.info(" ---> urProgramGetInfo({})\n", args_str_before.str()); + } ur_result_t result = pfnGetInfo(hProgram, propName, propSize, pPropValue, pPropSizeRet); @@ -3023,11 +3567,12 @@ __urdlllocal ur_result_t UR_APICALL urProgramGetInfo( getContext()->notify_end(UR_FUNCTION_PROGRAM_GET_INFO, "urProgramGetInfo", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_PROGRAM_GET_INFO, ¶ms); + logger.info(" <--- urProgramGetInfo({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -3063,8 +3608,15 @@ __urdlllocal ur_result_t UR_APICALL urProgramGetBuildInfo( UR_FUNCTION_PROGRAM_GET_BUILD_INFO, "urProgramGetBuildInfo", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urProgramGetBuildInfo"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_PROGRAM_GET_BUILD_INFO, ¶ms); + logger.info(" ---> urProgramGetBuildInfo({})\n", + args_str_before.str()); + } ur_result_t result = pfnGetBuildInfo(hProgram, hDevice, propName, propSize, pPropValue, pPropSizeRet); @@ -3073,11 +3625,12 @@ __urdlllocal ur_result_t UR_APICALL urProgramGetBuildInfo( "urProgramGetBuildInfo", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_PROGRAM_GET_BUILD_INFO, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_PROGRAM_GET_BUILD_INFO, ¶ms); + logger.info(" <--- urProgramGetBuildInfo({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -3106,8 +3659,16 @@ __urdlllocal ur_result_t UR_APICALL urProgramSetSpecializationConstants( "urProgramSetSpecializationConstants", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urProgramSetSpecializationConstants"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_PROGRAM_SET_SPECIALIZATION_CONSTANTS, + ¶ms); + logger.info(" ---> urProgramSetSpecializationConstants({})\n", + args_str_before.str()); + } ur_result_t result = pfnSetSpecializationConstants(hProgram, count, pSpecConstants); @@ -3116,12 +3677,13 @@ __urdlllocal ur_result_t UR_APICALL urProgramSetSpecializationConstants( "urProgramSetSpecializationConstants", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_PROGRAM_SET_SPECIALIZATION_CONSTANTS, + args_str_after, UR_FUNCTION_PROGRAM_SET_SPECIALIZATION_CONSTANTS, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + logger.info(" <--- urProgramSetSpecializationConstants({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -3148,8 +3710,15 @@ __urdlllocal ur_result_t UR_APICALL urProgramGetNativeHandle( "urProgramGetNativeHandle", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urProgramGetNativeHandle"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_PROGRAM_GET_NATIVE_HANDLE, ¶ms); + logger.info(" ---> urProgramGetNativeHandle({})\n", + args_str_before.str()); + } ur_result_t result = pfnGetNativeHandle(hProgram, phNativeProgram); @@ -3157,11 +3726,12 @@ __urdlllocal ur_result_t UR_APICALL urProgramGetNativeHandle( "urProgramGetNativeHandle", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_PROGRAM_GET_NATIVE_HANDLE, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_PROGRAM_GET_NATIVE_HANDLE, ¶ms); + logger.info(" <--- urProgramGetNativeHandle({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -3192,8 +3762,16 @@ __urdlllocal ur_result_t UR_APICALL urProgramCreateWithNativeHandle( "urProgramCreateWithNativeHandle", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urProgramCreateWithNativeHandle"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_PROGRAM_CREATE_WITH_NATIVE_HANDLE, + ¶ms); + logger.info(" ---> urProgramCreateWithNativeHandle({})\n", + args_str_before.str()); + } ur_result_t result = pfnCreateWithNativeHandle(hNativeProgram, hContext, pProperties, phProgram); @@ -3202,11 +3780,13 @@ __urdlllocal ur_result_t UR_APICALL urProgramCreateWithNativeHandle( "urProgramCreateWithNativeHandle", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_PROGRAM_CREATE_WITH_NATIVE_HANDLE, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_PROGRAM_CREATE_WITH_NATIVE_HANDLE, + ¶ms); + logger.info(" <--- urProgramCreateWithNativeHandle({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -3231,19 +3811,26 @@ __urdlllocal ur_result_t UR_APICALL urKernelCreate( "urKernelCreate", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urKernelCreate"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_KERNEL_CREATE, ¶ms); + logger.info(" ---> urKernelCreate({})\n", args_str_before.str()); + } ur_result_t result = pfnCreate(hProgram, pKernelName, phKernel); getContext()->notify_end(UR_FUNCTION_KERNEL_CREATE, "urKernelCreate", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_KERNEL_CREATE, ¶ms); + logger.info(" <--- urKernelCreate({}) -> {};\n", args_str_after.str(), + result); } return result; @@ -3273,8 +3860,14 @@ __urdlllocal ur_result_t UR_APICALL urKernelSetArgValue( UR_FUNCTION_KERNEL_SET_ARG_VALUE, "urKernelSetArgValue", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urKernelSetArgValue"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_KERNEL_SET_ARG_VALUE, ¶ms); + logger.info(" ---> urKernelSetArgValue({})\n", args_str_before.str()); + } ur_result_t result = pfnSetArgValue(hKernel, argIndex, argSize, pProperties, pArgValue); @@ -3282,11 +3875,12 @@ __urdlllocal ur_result_t UR_APICALL urKernelSetArgValue( getContext()->notify_end(UR_FUNCTION_KERNEL_SET_ARG_VALUE, "urKernelSetArgValue", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_KERNEL_SET_ARG_VALUE, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_KERNEL_SET_ARG_VALUE, ¶ms); + logger.info(" <--- urKernelSetArgValue({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -3314,8 +3908,14 @@ __urdlllocal ur_result_t UR_APICALL urKernelSetArgLocal( UR_FUNCTION_KERNEL_SET_ARG_LOCAL, "urKernelSetArgLocal", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urKernelSetArgLocal"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_KERNEL_SET_ARG_LOCAL, ¶ms); + logger.info(" ---> urKernelSetArgLocal({})\n", args_str_before.str()); + } ur_result_t result = pfnSetArgLocal(hKernel, argIndex, argSize, pProperties); @@ -3323,11 +3923,12 @@ __urdlllocal ur_result_t UR_APICALL urKernelSetArgLocal( getContext()->notify_end(UR_FUNCTION_KERNEL_SET_ARG_LOCAL, "urKernelSetArgLocal", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_KERNEL_SET_ARG_LOCAL, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_KERNEL_SET_ARG_LOCAL, ¶ms); + logger.info(" <--- urKernelSetArgLocal({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -3362,8 +3963,14 @@ __urdlllocal ur_result_t UR_APICALL urKernelGetInfo( "urKernelGetInfo", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urKernelGetInfo"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_KERNEL_GET_INFO, ¶ms); + logger.info(" ---> urKernelGetInfo({})\n", args_str_before.str()); + } ur_result_t result = pfnGetInfo(hKernel, propName, propSize, pPropValue, pPropSizeRet); @@ -3371,11 +3978,12 @@ __urdlllocal ur_result_t UR_APICALL urKernelGetInfo( getContext()->notify_end(UR_FUNCTION_KERNEL_GET_INFO, "urKernelGetInfo", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_KERNEL_GET_INFO, ¶ms); + logger.info(" <--- urKernelGetInfo({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -3408,8 +4016,15 @@ __urdlllocal ur_result_t UR_APICALL urKernelGetGroupInfo( UR_FUNCTION_KERNEL_GET_GROUP_INFO, "urKernelGetGroupInfo", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urKernelGetGroupInfo"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_KERNEL_GET_GROUP_INFO, ¶ms); + logger.info(" ---> urKernelGetGroupInfo({})\n", + args_str_before.str()); + } ur_result_t result = pfnGetGroupInfo(hKernel, hDevice, propName, propSize, pPropValue, pPropSizeRet); @@ -3418,11 +4033,12 @@ __urdlllocal ur_result_t UR_APICALL urKernelGetGroupInfo( "urKernelGetGroupInfo", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_KERNEL_GET_GROUP_INFO, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_KERNEL_GET_GROUP_INFO, ¶ms); + logger.info(" <--- urKernelGetGroupInfo({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -3457,8 +4073,15 @@ __urdlllocal ur_result_t UR_APICALL urKernelGetSubGroupInfo( "urKernelGetSubGroupInfo", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urKernelGetSubGroupInfo"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_KERNEL_GET_SUB_GROUP_INFO, ¶ms); + logger.info(" ---> urKernelGetSubGroupInfo({})\n", + args_str_before.str()); + } ur_result_t result = pfnGetSubGroupInfo(hKernel, hDevice, propName, propSize, pPropValue, pPropSizeRet); @@ -3467,11 +4090,12 @@ __urdlllocal ur_result_t UR_APICALL urKernelGetSubGroupInfo( "urKernelGetSubGroupInfo", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_KERNEL_GET_SUB_GROUP_INFO, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_KERNEL_GET_SUB_GROUP_INFO, ¶ms); + logger.info(" <--- urKernelGetSubGroupInfo({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -3493,19 +4117,26 @@ __urdlllocal ur_result_t UR_APICALL urKernelRetain( "urKernelRetain", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urKernelRetain"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_KERNEL_RETAIN, ¶ms); + logger.info(" ---> urKernelRetain({})\n", args_str_before.str()); + } ur_result_t result = pfnRetain(hKernel); getContext()->notify_end(UR_FUNCTION_KERNEL_RETAIN, "urKernelRetain", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_KERNEL_RETAIN, ¶ms); + logger.info(" <--- urKernelRetain({}) -> {};\n", args_str_after.str(), + result); } return result; @@ -3528,19 +4159,26 @@ __urdlllocal ur_result_t UR_APICALL urKernelRelease( "urKernelRelease", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urKernelRelease"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_KERNEL_RELEASE, ¶ms); + logger.info(" ---> urKernelRelease({})\n", args_str_before.str()); + } ur_result_t result = pfnRelease(hKernel); getContext()->notify_end(UR_FUNCTION_KERNEL_RELEASE, "urKernelRelease", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_KERNEL_RELEASE, ¶ms); + logger.info(" <--- urKernelRelease({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -3569,8 +4207,15 @@ __urdlllocal ur_result_t UR_APICALL urKernelSetArgPointer( UR_FUNCTION_KERNEL_SET_ARG_POINTER, "urKernelSetArgPointer", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urKernelSetArgPointer"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_KERNEL_SET_ARG_POINTER, ¶ms); + logger.info(" ---> urKernelSetArgPointer({})\n", + args_str_before.str()); + } ur_result_t result = pfnSetArgPointer(hKernel, argIndex, pProperties, pArgValue); @@ -3579,11 +4224,12 @@ __urdlllocal ur_result_t UR_APICALL urKernelSetArgPointer( "urKernelSetArgPointer", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_KERNEL_SET_ARG_POINTER, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_KERNEL_SET_ARG_POINTER, ¶ms); + logger.info(" <--- urKernelSetArgPointer({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -3613,8 +4259,14 @@ __urdlllocal ur_result_t UR_APICALL urKernelSetExecInfo( UR_FUNCTION_KERNEL_SET_EXEC_INFO, "urKernelSetExecInfo", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urKernelSetExecInfo"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_KERNEL_SET_EXEC_INFO, ¶ms); + logger.info(" ---> urKernelSetExecInfo({})\n", args_str_before.str()); + } ur_result_t result = pfnSetExecInfo(hKernel, propName, propSize, pProperties, pPropValue); @@ -3622,11 +4274,12 @@ __urdlllocal ur_result_t UR_APICALL urKernelSetExecInfo( getContext()->notify_end(UR_FUNCTION_KERNEL_SET_EXEC_INFO, "urKernelSetExecInfo", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_KERNEL_SET_EXEC_INFO, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_KERNEL_SET_EXEC_INFO, ¶ms); + logger.info(" <--- urKernelSetExecInfo({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -3653,8 +4306,15 @@ __urdlllocal ur_result_t UR_APICALL urKernelSetArgSampler( UR_FUNCTION_KERNEL_SET_ARG_SAMPLER, "urKernelSetArgSampler", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urKernelSetArgSampler"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_KERNEL_SET_ARG_SAMPLER, ¶ms); + logger.info(" ---> urKernelSetArgSampler({})\n", + args_str_before.str()); + } ur_result_t result = pfnSetArgSampler(hKernel, argIndex, pProperties, hArgValue); @@ -3663,11 +4323,12 @@ __urdlllocal ur_result_t UR_APICALL urKernelSetArgSampler( "urKernelSetArgSampler", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_KERNEL_SET_ARG_SAMPLER, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_KERNEL_SET_ARG_SAMPLER, ¶ms); + logger.info(" <--- urKernelSetArgSampler({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -3694,8 +4355,15 @@ __urdlllocal ur_result_t UR_APICALL urKernelSetArgMemObj( UR_FUNCTION_KERNEL_SET_ARG_MEM_OBJ, "urKernelSetArgMemObj", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urKernelSetArgMemObj"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_KERNEL_SET_ARG_MEM_OBJ, ¶ms); + logger.info(" ---> urKernelSetArgMemObj({})\n", + args_str_before.str()); + } ur_result_t result = pfnSetArgMemObj(hKernel, argIndex, pProperties, hArgValue); @@ -3704,11 +4372,12 @@ __urdlllocal ur_result_t UR_APICALL urKernelSetArgMemObj( "urKernelSetArgMemObj", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_KERNEL_SET_ARG_MEM_OBJ, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_KERNEL_SET_ARG_MEM_OBJ, ¶ms); + logger.info(" <--- urKernelSetArgMemObj({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -3736,8 +4405,16 @@ __urdlllocal ur_result_t UR_APICALL urKernelSetSpecializationConstants( "urKernelSetSpecializationConstants", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urKernelSetSpecializationConstants"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_KERNEL_SET_SPECIALIZATION_CONSTANTS, + ¶ms); + logger.info(" ---> urKernelSetSpecializationConstants({})\n", + args_str_before.str()); + } ur_result_t result = pfnSetSpecializationConstants(hKernel, count, pSpecConstants); @@ -3746,11 +4423,13 @@ __urdlllocal ur_result_t UR_APICALL urKernelSetSpecializationConstants( "urKernelSetSpecializationConstants", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_KERNEL_SET_SPECIALIZATION_CONSTANTS, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_KERNEL_SET_SPECIALIZATION_CONSTANTS, + ¶ms); + logger.info(" <--- urKernelSetSpecializationConstants({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -3776,8 +4455,15 @@ __urdlllocal ur_result_t UR_APICALL urKernelGetNativeHandle( "urKernelGetNativeHandle", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urKernelGetNativeHandle"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_KERNEL_GET_NATIVE_HANDLE, ¶ms); + logger.info(" ---> urKernelGetNativeHandle({})\n", + args_str_before.str()); + } ur_result_t result = pfnGetNativeHandle(hKernel, phNativeKernel); @@ -3785,11 +4471,12 @@ __urdlllocal ur_result_t UR_APICALL urKernelGetNativeHandle( "urKernelGetNativeHandle", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_KERNEL_GET_NATIVE_HANDLE, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_KERNEL_GET_NATIVE_HANDLE, ¶ms); + logger.info(" <--- urKernelGetNativeHandle({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -3822,8 +4509,16 @@ __urdlllocal ur_result_t UR_APICALL urKernelCreateWithNativeHandle( "urKernelCreateWithNativeHandle", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urKernelCreateWithNativeHandle"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_KERNEL_CREATE_WITH_NATIVE_HANDLE, + ¶ms); + logger.info(" ---> urKernelCreateWithNativeHandle({})\n", + args_str_before.str()); + } ur_result_t result = pfnCreateWithNativeHandle( hNativeKernel, hContext, hProgram, pProperties, phKernel); @@ -3832,11 +4527,13 @@ __urdlllocal ur_result_t UR_APICALL urKernelCreateWithNativeHandle( "urKernelCreateWithNativeHandle", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_KERNEL_CREATE_WITH_NATIVE_HANDLE, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_KERNEL_CREATE_WITH_NATIVE_HANDLE, + ¶ms); + logger.info(" <--- urKernelCreateWithNativeHandle({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -3876,8 +4573,16 @@ __urdlllocal ur_result_t UR_APICALL urKernelGetSuggestedLocalWorkSize( "urKernelGetSuggestedLocalWorkSize", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urKernelGetSuggestedLocalWorkSize"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_KERNEL_GET_SUGGESTED_LOCAL_WORK_SIZE, + ¶ms); + logger.info(" ---> urKernelGetSuggestedLocalWorkSize({})\n", + args_str_before.str()); + } ur_result_t result = pfnGetSuggestedLocalWorkSize( hKernel, hQueue, numWorkDim, pGlobalWorkOffset, pGlobalWorkSize, @@ -3887,12 +4592,13 @@ __urdlllocal ur_result_t UR_APICALL urKernelGetSuggestedLocalWorkSize( "urKernelGetSuggestedLocalWorkSize", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_KERNEL_GET_SUGGESTED_LOCAL_WORK_SIZE, + args_str_after, UR_FUNCTION_KERNEL_GET_SUGGESTED_LOCAL_WORK_SIZE, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + logger.info(" <--- urKernelGetSuggestedLocalWorkSize({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -3923,8 +4629,14 @@ __urdlllocal ur_result_t UR_APICALL urQueueGetInfo( "urQueueGetInfo", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urQueueGetInfo"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_QUEUE_GET_INFO, ¶ms); + logger.info(" ---> urQueueGetInfo({})\n", args_str_before.str()); + } ur_result_t result = pfnGetInfo(hQueue, propName, propSize, pPropValue, pPropSizeRet); @@ -3932,11 +4644,12 @@ __urdlllocal ur_result_t UR_APICALL urQueueGetInfo( getContext()->notify_end(UR_FUNCTION_QUEUE_GET_INFO, "urQueueGetInfo", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_QUEUE_GET_INFO, ¶ms); + logger.info(" <--- urQueueGetInfo({}) -> {};\n", args_str_after.str(), + result); } return result; @@ -3964,19 +4677,26 @@ __urdlllocal ur_result_t UR_APICALL urQueueCreate( "urQueueCreate", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urQueueCreate"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_QUEUE_CREATE, ¶ms); + logger.info(" ---> urQueueCreate({})\n", args_str_before.str()); + } ur_result_t result = pfnCreate(hContext, hDevice, pProperties, phQueue); getContext()->notify_end(UR_FUNCTION_QUEUE_CREATE, "urQueueCreate", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_QUEUE_CREATE, ¶ms); + logger.info(" <--- urQueueCreate({}) -> {};\n", args_str_after.str(), + result); } return result; @@ -3999,19 +4719,26 @@ __urdlllocal ur_result_t UR_APICALL urQueueRetain( "urQueueRetain", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urQueueRetain"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_QUEUE_RETAIN, ¶ms); + logger.info(" ---> urQueueRetain({})\n", args_str_before.str()); + } ur_result_t result = pfnRetain(hQueue); getContext()->notify_end(UR_FUNCTION_QUEUE_RETAIN, "urQueueRetain", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_QUEUE_RETAIN, ¶ms); + logger.info(" <--- urQueueRetain({}) -> {};\n", args_str_after.str(), + result); } return result; @@ -4034,19 +4761,26 @@ __urdlllocal ur_result_t UR_APICALL urQueueRelease( "urQueueRelease", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urQueueRelease"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_QUEUE_RELEASE, ¶ms); + logger.info(" ---> urQueueRelease({})\n", args_str_before.str()); + } ur_result_t result = pfnRelease(hQueue); getContext()->notify_end(UR_FUNCTION_QUEUE_RELEASE, "urQueueRelease", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_QUEUE_RELEASE, ¶ms); + logger.info(" <--- urQueueRelease({}) -> {};\n", args_str_after.str(), + result); } return result; @@ -4073,8 +4807,15 @@ __urdlllocal ur_result_t UR_APICALL urQueueGetNativeHandle( UR_FUNCTION_QUEUE_GET_NATIVE_HANDLE, "urQueueGetNativeHandle", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urQueueGetNativeHandle"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_QUEUE_GET_NATIVE_HANDLE, ¶ms); + logger.info(" ---> urQueueGetNativeHandle({})\n", + args_str_before.str()); + } ur_result_t result = pfnGetNativeHandle(hQueue, pDesc, phNativeQueue); @@ -4082,11 +4823,12 @@ __urdlllocal ur_result_t UR_APICALL urQueueGetNativeHandle( "urQueueGetNativeHandle", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_QUEUE_GET_NATIVE_HANDLE, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_QUEUE_GET_NATIVE_HANDLE, ¶ms); + logger.info(" <--- urQueueGetNativeHandle({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -4118,8 +4860,16 @@ __urdlllocal ur_result_t UR_APICALL urQueueCreateWithNativeHandle( "urQueueCreateWithNativeHandle", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urQueueCreateWithNativeHandle"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_QUEUE_CREATE_WITH_NATIVE_HANDLE, + ¶ms); + logger.info(" ---> urQueueCreateWithNativeHandle({})\n", + args_str_before.str()); + } ur_result_t result = pfnCreateWithNativeHandle( hNativeQueue, hContext, hDevice, pProperties, phQueue); @@ -4128,11 +4878,13 @@ __urdlllocal ur_result_t UR_APICALL urQueueCreateWithNativeHandle( "urQueueCreateWithNativeHandle", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_QUEUE_CREATE_WITH_NATIVE_HANDLE, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_QUEUE_CREATE_WITH_NATIVE_HANDLE, + ¶ms); + logger.info(" <--- urQueueCreateWithNativeHandle({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -4154,19 +4906,26 @@ __urdlllocal ur_result_t UR_APICALL urQueueFinish( "urQueueFinish", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urQueueFinish"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_QUEUE_FINISH, ¶ms); + logger.info(" ---> urQueueFinish({})\n", args_str_before.str()); + } ur_result_t result = pfnFinish(hQueue); getContext()->notify_end(UR_FUNCTION_QUEUE_FINISH, "urQueueFinish", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_QUEUE_FINISH, ¶ms); + logger.info(" <--- urQueueFinish({}) -> {};\n", args_str_after.str(), + result); } return result; @@ -4188,19 +4947,26 @@ __urdlllocal ur_result_t UR_APICALL urQueueFlush( "urQueueFlush", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urQueueFlush"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_QUEUE_FLUSH, ¶ms); + logger.info(" ---> urQueueFlush({})\n", args_str_before.str()); + } ur_result_t result = pfnFlush(hQueue); getContext()->notify_end(UR_FUNCTION_QUEUE_FLUSH, "urQueueFlush", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_QUEUE_FLUSH, + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, UR_FUNCTION_QUEUE_FLUSH, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + logger.info(" <--- urQueueFlush({}) -> {};\n", args_str_after.str(), + result); } return result; @@ -4229,8 +4995,14 @@ __urdlllocal ur_result_t UR_APICALL urEventGetInfo( "urEventGetInfo", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urEventGetInfo"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_EVENT_GET_INFO, ¶ms); + logger.info(" ---> urEventGetInfo({})\n", args_str_before.str()); + } ur_result_t result = pfnGetInfo(hEvent, propName, propSize, pPropValue, pPropSizeRet); @@ -4238,11 +5010,12 @@ __urdlllocal ur_result_t UR_APICALL urEventGetInfo( getContext()->notify_end(UR_FUNCTION_EVENT_GET_INFO, "urEventGetInfo", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_EVENT_GET_INFO, ¶ms); + logger.info(" <--- urEventGetInfo({}) -> {};\n", args_str_after.str(), + result); } return result; @@ -4276,8 +5049,15 @@ __urdlllocal ur_result_t UR_APICALL urEventGetProfilingInfo( "urEventGetProfilingInfo", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urEventGetProfilingInfo"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_EVENT_GET_PROFILING_INFO, ¶ms); + logger.info(" ---> urEventGetProfilingInfo({})\n", + args_str_before.str()); + } ur_result_t result = pfnGetProfilingInfo(hEvent, propName, propSize, pPropValue, pPropSizeRet); @@ -4286,11 +5066,12 @@ __urdlllocal ur_result_t UR_APICALL urEventGetProfilingInfo( "urEventGetProfilingInfo", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_EVENT_GET_PROFILING_INFO, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_EVENT_GET_PROFILING_INFO, ¶ms); + logger.info(" <--- urEventGetProfilingInfo({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -4315,19 +5096,26 @@ __urdlllocal ur_result_t UR_APICALL urEventWait( "urEventWait", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urEventWait"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, UR_FUNCTION_EVENT_WAIT, + ¶ms); + logger.info(" ---> urEventWait({})\n", args_str_before.str()); + } ur_result_t result = pfnWait(numEvents, phEventWaitList); getContext()->notify_end(UR_FUNCTION_EVENT_WAIT, "urEventWait", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; - ur::extras::printFunctionParams(args_str, UR_FUNCTION_EVENT_WAIT, + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, UR_FUNCTION_EVENT_WAIT, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + logger.info(" <--- urEventWait({}) -> {};\n", args_str_after.str(), + result); } return result; @@ -4349,19 +5137,26 @@ __urdlllocal ur_result_t UR_APICALL urEventRetain( "urEventRetain", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urEventRetain"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_EVENT_RETAIN, ¶ms); + logger.info(" ---> urEventRetain({})\n", args_str_before.str()); + } ur_result_t result = pfnRetain(hEvent); getContext()->notify_end(UR_FUNCTION_EVENT_RETAIN, "urEventRetain", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_EVENT_RETAIN, ¶ms); + logger.info(" <--- urEventRetain({}) -> {};\n", args_str_after.str(), + result); } return result; @@ -4383,19 +5178,26 @@ __urdlllocal ur_result_t UR_APICALL urEventRelease( "urEventRelease", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urEventRelease"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_EVENT_RELEASE, ¶ms); + logger.info(" ---> urEventRelease({})\n", args_str_before.str()); + } ur_result_t result = pfnRelease(hEvent); getContext()->notify_end(UR_FUNCTION_EVENT_RELEASE, "urEventRelease", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_EVENT_RELEASE, ¶ms); + logger.info(" <--- urEventRelease({}) -> {};\n", args_str_after.str(), + result); } return result; @@ -4419,8 +5221,15 @@ __urdlllocal ur_result_t UR_APICALL urEventGetNativeHandle( UR_FUNCTION_EVENT_GET_NATIVE_HANDLE, "urEventGetNativeHandle", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urEventGetNativeHandle"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_EVENT_GET_NATIVE_HANDLE, ¶ms); + logger.info(" ---> urEventGetNativeHandle({})\n", + args_str_before.str()); + } ur_result_t result = pfnGetNativeHandle(hEvent, phNativeEvent); @@ -4428,11 +5237,12 @@ __urdlllocal ur_result_t UR_APICALL urEventGetNativeHandle( "urEventGetNativeHandle", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_EVENT_GET_NATIVE_HANDLE, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_EVENT_GET_NATIVE_HANDLE, ¶ms); + logger.info(" <--- urEventGetNativeHandle({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -4463,8 +5273,16 @@ __urdlllocal ur_result_t UR_APICALL urEventCreateWithNativeHandle( "urEventCreateWithNativeHandle", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urEventCreateWithNativeHandle"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_EVENT_CREATE_WITH_NATIVE_HANDLE, + ¶ms); + logger.info(" ---> urEventCreateWithNativeHandle({})\n", + args_str_before.str()); + } ur_result_t result = pfnCreateWithNativeHandle(hNativeEvent, hContext, pProperties, phEvent); @@ -4473,11 +5291,13 @@ __urdlllocal ur_result_t UR_APICALL urEventCreateWithNativeHandle( "urEventCreateWithNativeHandle", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_EVENT_CREATE_WITH_NATIVE_HANDLE, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_EVENT_CREATE_WITH_NATIVE_HANDLE, + ¶ms); + logger.info(" <--- urEventCreateWithNativeHandle({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -4504,8 +5324,14 @@ __urdlllocal ur_result_t UR_APICALL urEventSetCallback( UR_FUNCTION_EVENT_SET_CALLBACK, "urEventSetCallback", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urEventSetCallback"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_EVENT_SET_CALLBACK, ¶ms); + logger.info(" ---> urEventSetCallback({})\n", args_str_before.str()); + } ur_result_t result = pfnSetCallback(hEvent, execStatus, pfnNotify, pUserData); @@ -4513,11 +5339,12 @@ __urdlllocal ur_result_t UR_APICALL urEventSetCallback( getContext()->notify_end(UR_FUNCTION_EVENT_SET_CALLBACK, "urEventSetCallback", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_EVENT_SET_CALLBACK, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_EVENT_SET_CALLBACK, ¶ms); + logger.info(" <--- urEventSetCallback({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -4573,8 +5400,15 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueKernelLaunch( UR_FUNCTION_ENQUEUE_KERNEL_LAUNCH, "urEnqueueKernelLaunch", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urEnqueueKernelLaunch"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_ENQUEUE_KERNEL_LAUNCH, ¶ms); + logger.info(" ---> urEnqueueKernelLaunch({})\n", + args_str_before.str()); + } ur_result_t result = pfnKernelLaunch( hQueue, hKernel, workDim, pGlobalWorkOffset, pGlobalWorkSize, @@ -4584,11 +5418,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueKernelLaunch( "urEnqueueKernelLaunch", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ENQUEUE_KERNEL_LAUNCH, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_ENQUEUE_KERNEL_LAUNCH, ¶ms); + logger.info(" <--- urEnqueueKernelLaunch({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -4621,8 +5456,14 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueEventsWait( UR_FUNCTION_ENQUEUE_EVENTS_WAIT, "urEnqueueEventsWait", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urEnqueueEventsWait"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_ENQUEUE_EVENTS_WAIT, ¶ms); + logger.info(" ---> urEnqueueEventsWait({})\n", args_str_before.str()); + } ur_result_t result = pfnEventsWait(hQueue, numEventsInWaitList, phEventWaitList, phEvent); @@ -4630,11 +5471,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueEventsWait( getContext()->notify_end(UR_FUNCTION_ENQUEUE_EVENTS_WAIT, "urEnqueueEventsWait", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ENQUEUE_EVENTS_WAIT, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_ENQUEUE_EVENTS_WAIT, ¶ms); + logger.info(" <--- urEnqueueEventsWait({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -4669,8 +5511,16 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueEventsWaitWithBarrier( "urEnqueueEventsWaitWithBarrier", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urEnqueueEventsWaitWithBarrier"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_ENQUEUE_EVENTS_WAIT_WITH_BARRIER, + ¶ms); + logger.info(" ---> urEnqueueEventsWaitWithBarrier({})\n", + args_str_before.str()); + } ur_result_t result = pfnEventsWaitWithBarrier(hQueue, numEventsInWaitList, phEventWaitList, phEvent); @@ -4679,11 +5529,13 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueEventsWaitWithBarrier( "urEnqueueEventsWaitWithBarrier", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ENQUEUE_EVENTS_WAIT_WITH_BARRIER, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_ENQUEUE_EVENTS_WAIT_WITH_BARRIER, + ¶ms); + logger.info(" <--- urEnqueueEventsWaitWithBarrier({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -4723,8 +5575,15 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemBufferRead( UR_FUNCTION_ENQUEUE_MEM_BUFFER_READ, "urEnqueueMemBufferRead", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urEnqueueMemBufferRead"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_ENQUEUE_MEM_BUFFER_READ, ¶ms); + logger.info(" ---> urEnqueueMemBufferRead({})\n", + args_str_before.str()); + } ur_result_t result = pfnMemBufferRead(hQueue, hBuffer, blockingRead, offset, size, pDst, @@ -4734,11 +5593,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemBufferRead( "urEnqueueMemBufferRead", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ENQUEUE_MEM_BUFFER_READ, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_ENQUEUE_MEM_BUFFER_READ, ¶ms); + logger.info(" <--- urEnqueueMemBufferRead({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -4781,8 +5641,15 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemBufferWrite( "urEnqueueMemBufferWrite", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urEnqueueMemBufferWrite"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_ENQUEUE_MEM_BUFFER_WRITE, ¶ms); + logger.info(" ---> urEnqueueMemBufferWrite({})\n", + args_str_before.str()); + } ur_result_t result = pfnMemBufferWrite(hQueue, hBuffer, blockingWrite, offset, size, pSrc, @@ -4792,11 +5659,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemBufferWrite( "urEnqueueMemBufferWrite", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ENQUEUE_MEM_BUFFER_WRITE, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_ENQUEUE_MEM_BUFFER_WRITE, ¶ms); + logger.info(" <--- urEnqueueMemBufferWrite({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -4860,8 +5728,15 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemBufferReadRect( "urEnqueueMemBufferReadRect", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urEnqueueMemBufferReadRect"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_ENQUEUE_MEM_BUFFER_READ_RECT, ¶ms); + logger.info(" ---> urEnqueueMemBufferReadRect({})\n", + args_str_before.str()); + } ur_result_t result = pfnMemBufferReadRect( hQueue, hBuffer, blockingRead, bufferOrigin, hostOrigin, region, @@ -4872,11 +5747,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemBufferReadRect( "urEnqueueMemBufferReadRect", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ENQUEUE_MEM_BUFFER_READ_RECT, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_ENQUEUE_MEM_BUFFER_READ_RECT, ¶ms); + logger.info(" <--- urEnqueueMemBufferReadRect({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -4943,8 +5819,16 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemBufferWriteRect( "urEnqueueMemBufferWriteRect", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urEnqueueMemBufferWriteRect"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_ENQUEUE_MEM_BUFFER_WRITE_RECT, + ¶ms); + logger.info(" ---> urEnqueueMemBufferWriteRect({})\n", + args_str_before.str()); + } ur_result_t result = pfnMemBufferWriteRect( hQueue, hBuffer, blockingWrite, bufferOrigin, hostOrigin, region, @@ -4955,11 +5839,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemBufferWriteRect( "urEnqueueMemBufferWriteRect", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ENQUEUE_MEM_BUFFER_WRITE_RECT, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_ENQUEUE_MEM_BUFFER_WRITE_RECT, ¶ms); + logger.info(" <--- urEnqueueMemBufferWriteRect({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -4999,8 +5884,15 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemBufferCopy( UR_FUNCTION_ENQUEUE_MEM_BUFFER_COPY, "urEnqueueMemBufferCopy", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urEnqueueMemBufferCopy"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_ENQUEUE_MEM_BUFFER_COPY, ¶ms); + logger.info(" ---> urEnqueueMemBufferCopy({})\n", + args_str_before.str()); + } ur_result_t result = pfnMemBufferCopy(hQueue, hBufferSrc, hBufferDst, srcOffset, dstOffset, @@ -5010,11 +5902,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemBufferCopy( "urEnqueueMemBufferCopy", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ENQUEUE_MEM_BUFFER_COPY, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_ENQUEUE_MEM_BUFFER_COPY, ¶ms); + logger.info(" <--- urEnqueueMemBufferCopy({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -5067,8 +5960,15 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemBufferCopyRect( "urEnqueueMemBufferCopyRect", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urEnqueueMemBufferCopyRect"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_ENQUEUE_MEM_BUFFER_COPY_RECT, ¶ms); + logger.info(" ---> urEnqueueMemBufferCopyRect({})\n", + args_str_before.str()); + } ur_result_t result = pfnMemBufferCopyRect( hQueue, hBufferSrc, hBufferDst, srcOrigin, dstOrigin, region, @@ -5079,11 +5979,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemBufferCopyRect( "urEnqueueMemBufferCopyRect", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ENQUEUE_MEM_BUFFER_COPY_RECT, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_ENQUEUE_MEM_BUFFER_COPY_RECT, ¶ms); + logger.info(" <--- urEnqueueMemBufferCopyRect({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -5128,8 +6029,15 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemBufferFill( UR_FUNCTION_ENQUEUE_MEM_BUFFER_FILL, "urEnqueueMemBufferFill", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urEnqueueMemBufferFill"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_ENQUEUE_MEM_BUFFER_FILL, ¶ms); + logger.info(" ---> urEnqueueMemBufferFill({})\n", + args_str_before.str()); + } ur_result_t result = pfnMemBufferFill(hQueue, hBuffer, pPattern, patternSize, offset, size, @@ -5139,11 +6047,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemBufferFill( "urEnqueueMemBufferFill", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ENQUEUE_MEM_BUFFER_FILL, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_ENQUEUE_MEM_BUFFER_FILL, ¶ms); + logger.info(" <--- urEnqueueMemBufferFill({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -5189,8 +6098,15 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemImageRead( UR_FUNCTION_ENQUEUE_MEM_IMAGE_READ, "urEnqueueMemImageRead", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urEnqueueMemImageRead"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_ENQUEUE_MEM_IMAGE_READ, ¶ms); + logger.info(" ---> urEnqueueMemImageRead({})\n", + args_str_before.str()); + } ur_result_t result = pfnMemImageRead( hQueue, hImage, blockingRead, origin, region, rowPitch, slicePitch, @@ -5200,11 +6116,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemImageRead( "urEnqueueMemImageRead", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ENQUEUE_MEM_IMAGE_READ, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_ENQUEUE_MEM_IMAGE_READ, ¶ms); + logger.info(" <--- urEnqueueMemImageRead({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -5251,8 +6168,15 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemImageWrite( UR_FUNCTION_ENQUEUE_MEM_IMAGE_WRITE, "urEnqueueMemImageWrite", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urEnqueueMemImageWrite"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_ENQUEUE_MEM_IMAGE_WRITE, ¶ms); + logger.info(" ---> urEnqueueMemImageWrite({})\n", + args_str_before.str()); + } ur_result_t result = pfnMemImageWrite( hQueue, hImage, blockingWrite, origin, region, rowPitch, slicePitch, @@ -5262,11 +6186,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemImageWrite( "urEnqueueMemImageWrite", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ENQUEUE_MEM_IMAGE_WRITE, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_ENQUEUE_MEM_IMAGE_WRITE, ¶ms); + logger.info(" <--- urEnqueueMemImageWrite({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -5312,8 +6237,15 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemImageCopy( UR_FUNCTION_ENQUEUE_MEM_IMAGE_COPY, "urEnqueueMemImageCopy", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urEnqueueMemImageCopy"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_ENQUEUE_MEM_IMAGE_COPY, ¶ms); + logger.info(" ---> urEnqueueMemImageCopy({})\n", + args_str_before.str()); + } ur_result_t result = pfnMemImageCopy(hQueue, hImageSrc, hImageDst, srcOrigin, dstOrigin, @@ -5323,11 +6255,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemImageCopy( "urEnqueueMemImageCopy", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ENQUEUE_MEM_IMAGE_COPY, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_ENQUEUE_MEM_IMAGE_COPY, ¶ms); + logger.info(" <--- urEnqueueMemImageCopy({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -5369,8 +6302,15 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemBufferMap( UR_FUNCTION_ENQUEUE_MEM_BUFFER_MAP, "urEnqueueMemBufferMap", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urEnqueueMemBufferMap"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_ENQUEUE_MEM_BUFFER_MAP, ¶ms); + logger.info(" ---> urEnqueueMemBufferMap({})\n", + args_str_before.str()); + } ur_result_t result = pfnMemBufferMap(hQueue, hBuffer, blockingMap, mapFlags, offset, size, numEventsInWaitList, @@ -5380,11 +6320,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemBufferMap( "urEnqueueMemBufferMap", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ENQUEUE_MEM_BUFFER_MAP, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_ENQUEUE_MEM_BUFFER_MAP, ¶ms); + logger.info(" <--- urEnqueueMemBufferMap({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -5420,8 +6361,14 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemUnmap( UR_FUNCTION_ENQUEUE_MEM_UNMAP, "urEnqueueMemUnmap", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urEnqueueMemUnmap"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_ENQUEUE_MEM_UNMAP, ¶ms); + logger.info(" ---> urEnqueueMemUnmap({})\n", args_str_before.str()); + } ur_result_t result = pfnMemUnmap(hQueue, hMem, pMappedPtr, numEventsInWaitList, @@ -5430,11 +6377,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemUnmap( getContext()->notify_end(UR_FUNCTION_ENQUEUE_MEM_UNMAP, "urEnqueueMemUnmap", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_ENQUEUE_MEM_UNMAP, ¶ms); + logger.info(" <--- urEnqueueMemUnmap({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -5476,8 +6424,14 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueUSMFill( "urEnqueueUSMFill", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urEnqueueUSMFill"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_ENQUEUE_USM_FILL, ¶ms); + logger.info(" ---> urEnqueueUSMFill({})\n", args_str_before.str()); + } ur_result_t result = pfnUSMFill(hQueue, pMem, patternSize, pPattern, size, @@ -5486,11 +6440,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueUSMFill( getContext()->notify_end(UR_FUNCTION_ENQUEUE_USM_FILL, "urEnqueueUSMFill", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_ENQUEUE_USM_FILL, ¶ms); + logger.info(" <--- urEnqueueUSMFill({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -5529,8 +6484,14 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueUSMMemcpy( UR_FUNCTION_ENQUEUE_USM_MEMCPY, "urEnqueueUSMMemcpy", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urEnqueueUSMMemcpy"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_ENQUEUE_USM_MEMCPY, ¶ms); + logger.info(" ---> urEnqueueUSMMemcpy({})\n", args_str_before.str()); + } ur_result_t result = pfnUSMMemcpy(hQueue, blocking, pDst, pSrc, size, numEventsInWaitList, @@ -5539,11 +6500,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueUSMMemcpy( getContext()->notify_end(UR_FUNCTION_ENQUEUE_USM_MEMCPY, "urEnqueueUSMMemcpy", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ENQUEUE_USM_MEMCPY, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_ENQUEUE_USM_MEMCPY, ¶ms); + logger.info(" <--- urEnqueueUSMMemcpy({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -5580,8 +6542,15 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueUSMPrefetch( UR_FUNCTION_ENQUEUE_USM_PREFETCH, "urEnqueueUSMPrefetch", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urEnqueueUSMPrefetch"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_ENQUEUE_USM_PREFETCH, ¶ms); + logger.info(" ---> urEnqueueUSMPrefetch({})\n", + args_str_before.str()); + } ur_result_t result = pfnUSMPrefetch(hQueue, pMem, size, flags, numEventsInWaitList, @@ -5591,11 +6560,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueUSMPrefetch( "urEnqueueUSMPrefetch", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ENQUEUE_USM_PREFETCH, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_ENQUEUE_USM_PREFETCH, ¶ms); + logger.info(" <--- urEnqueueUSMPrefetch({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -5625,19 +6595,26 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueUSMAdvise( UR_FUNCTION_ENQUEUE_USM_ADVISE, "urEnqueueUSMAdvise", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urEnqueueUSMAdvise"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_ENQUEUE_USM_ADVISE, ¶ms); + logger.info(" ---> urEnqueueUSMAdvise({})\n", args_str_before.str()); + } ur_result_t result = pfnUSMAdvise(hQueue, pMem, size, advice, phEvent); getContext()->notify_end(UR_FUNCTION_ENQUEUE_USM_ADVISE, "urEnqueueUSMAdvise", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ENQUEUE_USM_ADVISE, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_ENQUEUE_USM_ADVISE, ¶ms); + logger.info(" <--- urEnqueueUSMAdvise({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -5684,8 +6661,14 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueUSMFill2D( UR_FUNCTION_ENQUEUE_USM_FILL_2D, "urEnqueueUSMFill2D", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urEnqueueUSMFill2D"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_ENQUEUE_USM_FILL_2D, ¶ms); + logger.info(" ---> urEnqueueUSMFill2D({})\n", args_str_before.str()); + } ur_result_t result = pfnUSMFill2D(hQueue, pMem, pitch, patternSize, pPattern, width, height, @@ -5694,11 +6677,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueUSMFill2D( getContext()->notify_end(UR_FUNCTION_ENQUEUE_USM_FILL_2D, "urEnqueueUSMFill2D", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ENQUEUE_USM_FILL_2D, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_ENQUEUE_USM_FILL_2D, ¶ms); + logger.info(" <--- urEnqueueUSMFill2D({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -5745,8 +6729,15 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueUSMMemcpy2D( UR_FUNCTION_ENQUEUE_USM_MEMCPY_2D, "urEnqueueUSMMemcpy2D", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urEnqueueUSMMemcpy2D"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_ENQUEUE_USM_MEMCPY_2D, ¶ms); + logger.info(" ---> urEnqueueUSMMemcpy2D({})\n", + args_str_before.str()); + } ur_result_t result = pfnUSMMemcpy2D(hQueue, blocking, pDst, dstPitch, pSrc, srcPitch, width, @@ -5756,11 +6747,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueUSMMemcpy2D( "urEnqueueUSMMemcpy2D", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ENQUEUE_USM_MEMCPY_2D, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_ENQUEUE_USM_MEMCPY_2D, ¶ms); + logger.info(" <--- urEnqueueUSMMemcpy2D({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -5805,8 +6797,16 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueDeviceGlobalVariableWrite( "urEnqueueDeviceGlobalVariableWrite", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urEnqueueDeviceGlobalVariableWrite"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_ENQUEUE_DEVICE_GLOBAL_VARIABLE_WRITE, + ¶ms); + logger.info(" ---> urEnqueueDeviceGlobalVariableWrite({})\n", + args_str_before.str()); + } ur_result_t result = pfnDeviceGlobalVariableWrite( hQueue, hProgram, name, blockingWrite, count, offset, pSrc, @@ -5816,12 +6816,13 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueDeviceGlobalVariableWrite( "urEnqueueDeviceGlobalVariableWrite", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ENQUEUE_DEVICE_GLOBAL_VARIABLE_WRITE, + args_str_after, UR_FUNCTION_ENQUEUE_DEVICE_GLOBAL_VARIABLE_WRITE, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + logger.info(" <--- urEnqueueDeviceGlobalVariableWrite({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -5866,8 +6867,16 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueDeviceGlobalVariableRead( "urEnqueueDeviceGlobalVariableRead", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urEnqueueDeviceGlobalVariableRead"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_ENQUEUE_DEVICE_GLOBAL_VARIABLE_READ, + ¶ms); + logger.info(" ---> urEnqueueDeviceGlobalVariableRead({})\n", + args_str_before.str()); + } ur_result_t result = pfnDeviceGlobalVariableRead( hQueue, hProgram, name, blockingRead, count, offset, pDst, @@ -5877,11 +6886,13 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueDeviceGlobalVariableRead( "urEnqueueDeviceGlobalVariableRead", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ENQUEUE_DEVICE_GLOBAL_VARIABLE_READ, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_ENQUEUE_DEVICE_GLOBAL_VARIABLE_READ, + ¶ms); + logger.info(" <--- urEnqueueDeviceGlobalVariableRead({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -5928,8 +6939,15 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueReadHostPipe( UR_FUNCTION_ENQUEUE_READ_HOST_PIPE, "urEnqueueReadHostPipe", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urEnqueueReadHostPipe"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_ENQUEUE_READ_HOST_PIPE, ¶ms); + logger.info(" ---> urEnqueueReadHostPipe({})\n", + args_str_before.str()); + } ur_result_t result = pfnReadHostPipe(hQueue, hProgram, pipe_symbol, blocking, pDst, size, @@ -5939,11 +6957,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueReadHostPipe( "urEnqueueReadHostPipe", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ENQUEUE_READ_HOST_PIPE, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_ENQUEUE_READ_HOST_PIPE, ¶ms); + logger.info(" <--- urEnqueueReadHostPipe({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -5990,8 +7009,15 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueWriteHostPipe( UR_FUNCTION_ENQUEUE_WRITE_HOST_PIPE, "urEnqueueWriteHostPipe", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urEnqueueWriteHostPipe"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_ENQUEUE_WRITE_HOST_PIPE, ¶ms); + logger.info(" ---> urEnqueueWriteHostPipe({})\n", + args_str_before.str()); + } ur_result_t result = pfnWriteHostPipe(hQueue, hProgram, pipe_symbol, blocking, pSrc, size, @@ -6001,11 +7027,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueWriteHostPipe( "urEnqueueWriteHostPipe", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ENQUEUE_WRITE_HOST_PIPE, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_ENQUEUE_WRITE_HOST_PIPE, ¶ms); + logger.info(" <--- urEnqueueWriteHostPipe({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -6042,8 +7069,15 @@ __urdlllocal ur_result_t UR_APICALL urUSMPitchedAllocExp( UR_FUNCTION_USM_PITCHED_ALLOC_EXP, "urUSMPitchedAllocExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urUSMPitchedAllocExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_USM_PITCHED_ALLOC_EXP, ¶ms); + logger.info(" ---> urUSMPitchedAllocExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnPitchedAllocExp(hContext, hDevice, pUSMDesc, pool, widthInBytes, @@ -6053,11 +7087,12 @@ __urdlllocal ur_result_t UR_APICALL urUSMPitchedAllocExp( "urUSMPitchedAllocExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_USM_PITCHED_ALLOC_EXP, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_USM_PITCHED_ALLOC_EXP, ¶ms); + logger.info(" <--- urUSMPitchedAllocExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -6087,8 +7122,18 @@ urBindlessImagesUnsampledImageHandleDestroyExp( "urBindlessImagesUnsampledImageHandleDestroyExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urBindlessImagesUnsampledImageHandleDestroyExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, + UR_FUNCTION_BINDLESS_IMAGES_UNSAMPLED_IMAGE_HANDLE_DESTROY_EXP, + ¶ms); + logger.info( + " ---> urBindlessImagesUnsampledImageHandleDestroyExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnUnsampledImageHandleDestroyExp(hContext, hDevice, hImage); @@ -6098,13 +7143,16 @@ urBindlessImagesUnsampledImageHandleDestroyExp( "urBindlessImagesUnsampledImageHandleDestroyExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, + args_str_after, UR_FUNCTION_BINDLESS_IMAGES_UNSAMPLED_IMAGE_HANDLE_DESTROY_EXP, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + logger.info( + " <--- urBindlessImagesUnsampledImageHandleDestroyExp({}) -> " + "{};\n", + args_str_after.str(), result); } return result; @@ -6134,8 +7182,18 @@ urBindlessImagesSampledImageHandleDestroyExp( "urBindlessImagesSampledImageHandleDestroyExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urBindlessImagesSampledImageHandleDestroyExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, + UR_FUNCTION_BINDLESS_IMAGES_SAMPLED_IMAGE_HANDLE_DESTROY_EXP, + ¶ms); + logger.info( + " ---> urBindlessImagesSampledImageHandleDestroyExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnSampledImageHandleDestroyExp(hContext, hDevice, hImage); @@ -6145,13 +7203,15 @@ urBindlessImagesSampledImageHandleDestroyExp( "urBindlessImagesSampledImageHandleDestroyExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, + args_str_after, UR_FUNCTION_BINDLESS_IMAGES_SAMPLED_IMAGE_HANDLE_DESTROY_EXP, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + logger.info( + " <--- urBindlessImagesSampledImageHandleDestroyExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -6182,8 +7242,16 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesImageAllocateExp( "urBindlessImagesImageAllocateExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urBindlessImagesImageAllocateExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_BINDLESS_IMAGES_IMAGE_ALLOCATE_EXP, + ¶ms); + logger.info(" ---> urBindlessImagesImageAllocateExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnImageAllocateExp(hContext, hDevice, pImageFormat, pImageDesc, phImageMem); @@ -6192,11 +7260,13 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesImageAllocateExp( "urBindlessImagesImageAllocateExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_BINDLESS_IMAGES_IMAGE_ALLOCATE_EXP, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_BINDLESS_IMAGES_IMAGE_ALLOCATE_EXP, + ¶ms); + logger.info(" <--- urBindlessImagesImageAllocateExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -6224,8 +7294,16 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesImageFreeExp( "urBindlessImagesImageFreeExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urBindlessImagesImageFreeExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_BINDLESS_IMAGES_IMAGE_FREE_EXP, + ¶ms); + logger.info(" ---> urBindlessImagesImageFreeExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnImageFreeExp(hContext, hDevice, hImageMem); @@ -6233,11 +7311,13 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesImageFreeExp( "urBindlessImagesImageFreeExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_BINDLESS_IMAGES_IMAGE_FREE_EXP, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_BINDLESS_IMAGES_IMAGE_FREE_EXP, + ¶ms); + logger.info(" <--- urBindlessImagesImageFreeExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -6270,8 +7350,16 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesUnsampledImageCreateExp( "urBindlessImagesUnsampledImageCreateExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urBindlessImagesUnsampledImageCreateExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, + UR_FUNCTION_BINDLESS_IMAGES_UNSAMPLED_IMAGE_CREATE_EXP, ¶ms); + logger.info(" ---> urBindlessImagesUnsampledImageCreateExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnUnsampledImageCreateExp( hContext, hDevice, hImageMem, pImageFormat, pImageDesc, phImage); @@ -6280,12 +7368,14 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesUnsampledImageCreateExp( UR_FUNCTION_BINDLESS_IMAGES_UNSAMPLED_IMAGE_CREATE_EXP, "urBindlessImagesUnsampledImageCreateExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_BINDLESS_IMAGES_UNSAMPLED_IMAGE_CREATE_EXP, - ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, + UR_FUNCTION_BINDLESS_IMAGES_UNSAMPLED_IMAGE_CREATE_EXP, ¶ms); + logger.info( + " <--- urBindlessImagesUnsampledImageCreateExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -6320,8 +7410,16 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesSampledImageCreateExp( "urBindlessImagesSampledImageCreateExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urBindlessImagesSampledImageCreateExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, + UR_FUNCTION_BINDLESS_IMAGES_SAMPLED_IMAGE_CREATE_EXP, ¶ms); + logger.info(" ---> urBindlessImagesSampledImageCreateExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnSampledImageCreateExp(hContext, hDevice, hImageMem, pImageFormat, @@ -6331,12 +7429,14 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesSampledImageCreateExp( UR_FUNCTION_BINDLESS_IMAGES_SAMPLED_IMAGE_CREATE_EXP, "urBindlessImagesSampledImageCreateExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_BINDLESS_IMAGES_SAMPLED_IMAGE_CREATE_EXP, - ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, + UR_FUNCTION_BINDLESS_IMAGES_SAMPLED_IMAGE_CREATE_EXP, ¶ms); + logger.info( + " <--- urBindlessImagesSampledImageCreateExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -6394,8 +7494,16 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesImageCopyExp( "urBindlessImagesImageCopyExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urBindlessImagesImageCopyExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_BINDLESS_IMAGES_IMAGE_COPY_EXP, + ¶ms); + logger.info(" ---> urBindlessImagesImageCopyExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnImageCopyExp( hQueue, pSrc, pDst, pSrcImageDesc, pDstImageDesc, pSrcImageFormat, @@ -6406,11 +7514,13 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesImageCopyExp( "urBindlessImagesImageCopyExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_BINDLESS_IMAGES_IMAGE_COPY_EXP, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_BINDLESS_IMAGES_IMAGE_COPY_EXP, + ¶ms); + logger.info(" <--- urBindlessImagesImageCopyExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -6440,8 +7550,16 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesImageGetInfoExp( "urBindlessImagesImageGetInfoExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urBindlessImagesImageGetInfoExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_BINDLESS_IMAGES_IMAGE_GET_INFO_EXP, + ¶ms); + logger.info(" ---> urBindlessImagesImageGetInfoExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnImageGetInfoExp(hContext, hImageMem, propName, pPropValue, pPropSizeRet); @@ -6450,11 +7568,13 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesImageGetInfoExp( "urBindlessImagesImageGetInfoExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_BINDLESS_IMAGES_IMAGE_GET_INFO_EXP, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_BINDLESS_IMAGES_IMAGE_GET_INFO_EXP, + ¶ms); + logger.info(" <--- urBindlessImagesImageGetInfoExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -6485,8 +7605,16 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesMipmapGetLevelExp( "urBindlessImagesMipmapGetLevelExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urBindlessImagesMipmapGetLevelExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_BINDLESS_IMAGES_MIPMAP_GET_LEVEL_EXP, + ¶ms); + logger.info(" ---> urBindlessImagesMipmapGetLevelExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnMipmapGetLevelExp(hContext, hDevice, hImageMem, mipmapLevel, phImageMem); @@ -6495,12 +7623,13 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesMipmapGetLevelExp( "urBindlessImagesMipmapGetLevelExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_BINDLESS_IMAGES_MIPMAP_GET_LEVEL_EXP, + args_str_after, UR_FUNCTION_BINDLESS_IMAGES_MIPMAP_GET_LEVEL_EXP, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + logger.info(" <--- urBindlessImagesMipmapGetLevelExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -6528,8 +7657,16 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesMipmapFreeExp( "urBindlessImagesMipmapFreeExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urBindlessImagesMipmapFreeExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_BINDLESS_IMAGES_MIPMAP_FREE_EXP, + ¶ms); + logger.info(" ---> urBindlessImagesMipmapFreeExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnMipmapFreeExp(hContext, hDevice, hMem); @@ -6537,11 +7674,13 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesMipmapFreeExp( "urBindlessImagesMipmapFreeExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_BINDLESS_IMAGES_MIPMAP_FREE_EXP, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_BINDLESS_IMAGES_MIPMAP_FREE_EXP, + ¶ms); + logger.info(" <--- urBindlessImagesMipmapFreeExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -6575,8 +7714,16 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesImportExternalMemoryExp( "urBindlessImagesImportExternalMemoryExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urBindlessImagesImportExternalMemoryExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, + UR_FUNCTION_BINDLESS_IMAGES_IMPORT_EXTERNAL_MEMORY_EXP, ¶ms); + logger.info(" ---> urBindlessImagesImportExternalMemoryExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnImportExternalMemoryExp(hContext, hDevice, size, memHandleType, @@ -6586,12 +7733,14 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesImportExternalMemoryExp( UR_FUNCTION_BINDLESS_IMAGES_IMPORT_EXTERNAL_MEMORY_EXP, "urBindlessImagesImportExternalMemoryExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_BINDLESS_IMAGES_IMPORT_EXTERNAL_MEMORY_EXP, - ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, + UR_FUNCTION_BINDLESS_IMAGES_IMPORT_EXTERNAL_MEMORY_EXP, ¶ms); + logger.info( + " <--- urBindlessImagesImportExternalMemoryExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -6625,8 +7774,16 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesMapExternalArrayExp( "urBindlessImagesMapExternalArrayExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urBindlessImagesMapExternalArrayExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_BINDLESS_IMAGES_MAP_EXTERNAL_ARRAY_EXP, + ¶ms); + logger.info(" ---> urBindlessImagesMapExternalArrayExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnMapExternalArrayExp( hContext, hDevice, pImageFormat, pImageDesc, hExternalMem, phImageMem); @@ -6635,12 +7792,13 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesMapExternalArrayExp( "urBindlessImagesMapExternalArrayExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_BINDLESS_IMAGES_MAP_EXTERNAL_ARRAY_EXP, + args_str_after, UR_FUNCTION_BINDLESS_IMAGES_MAP_EXTERNAL_ARRAY_EXP, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + logger.info(" <--- urBindlessImagesMapExternalArrayExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -6672,8 +7830,17 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesMapExternalLinearMemoryExp( "urBindlessImagesMapExternalLinearMemoryExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urBindlessImagesMapExternalLinearMemoryExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, + UR_FUNCTION_BINDLESS_IMAGES_MAP_EXTERNAL_LINEAR_MEMORY_EXP, + ¶ms); + logger.info(" ---> urBindlessImagesMapExternalLinearMemoryExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnMapExternalLinearMemoryExp( hContext, hDevice, offset, size, hExternalMem, ppRetMem); @@ -6683,13 +7850,15 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesMapExternalLinearMemoryExp( "urBindlessImagesMapExternalLinearMemoryExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, + args_str_after, UR_FUNCTION_BINDLESS_IMAGES_MAP_EXTERNAL_LINEAR_MEMORY_EXP, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + logger.info( + " <--- urBindlessImagesMapExternalLinearMemoryExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -6717,8 +7886,16 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesReleaseExternalMemoryExp( "urBindlessImagesReleaseExternalMemoryExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urBindlessImagesReleaseExternalMemoryExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, + UR_FUNCTION_BINDLESS_IMAGES_RELEASE_EXTERNAL_MEMORY_EXP, ¶ms); + logger.info(" ---> urBindlessImagesReleaseExternalMemoryExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnReleaseExternalMemoryExp(hContext, hDevice, hExternalMem); @@ -6727,12 +7904,14 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesReleaseExternalMemoryExp( UR_FUNCTION_BINDLESS_IMAGES_RELEASE_EXTERNAL_MEMORY_EXP, "urBindlessImagesReleaseExternalMemoryExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_BINDLESS_IMAGES_RELEASE_EXTERNAL_MEMORY_EXP, - ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, + UR_FUNCTION_BINDLESS_IMAGES_RELEASE_EXTERNAL_MEMORY_EXP, ¶ms); + logger.info( + " <--- urBindlessImagesReleaseExternalMemoryExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -6766,8 +7945,16 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesImportExternalSemaphoreExp( "urBindlessImagesImportExternalSemaphoreExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urBindlessImagesImportExternalSemaphoreExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, + UR_FUNCTION_BINDLESS_IMAGES_IMPORT_EXTERNAL_SEMAPHORE_EXP, ¶ms); + logger.info(" ---> urBindlessImagesImportExternalSemaphoreExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnImportExternalSemaphoreExp( hContext, hDevice, semHandleType, pExternalSemaphoreDesc, @@ -6778,12 +7965,14 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesImportExternalSemaphoreExp( "urBindlessImagesImportExternalSemaphoreExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_BINDLESS_IMAGES_IMPORT_EXTERNAL_SEMAPHORE_EXP, - ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, + UR_FUNCTION_BINDLESS_IMAGES_IMPORT_EXTERNAL_SEMAPHORE_EXP, ¶ms); + logger.info( + " <--- urBindlessImagesImportExternalSemaphoreExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -6812,8 +8001,17 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesReleaseExternalSemaphoreExp( "urBindlessImagesReleaseExternalSemaphoreExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urBindlessImagesReleaseExternalSemaphoreExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, + UR_FUNCTION_BINDLESS_IMAGES_RELEASE_EXTERNAL_SEMAPHORE_EXP, + ¶ms); + logger.info(" ---> urBindlessImagesReleaseExternalSemaphoreExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnReleaseExternalSemaphoreExp(hContext, hDevice, hExternalSemaphore); @@ -6823,13 +8021,15 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesReleaseExternalSemaphoreExp( "urBindlessImagesReleaseExternalSemaphoreExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, + args_str_after, UR_FUNCTION_BINDLESS_IMAGES_RELEASE_EXTERNAL_SEMAPHORE_EXP, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + logger.info( + " <--- urBindlessImagesReleaseExternalSemaphoreExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -6874,8 +8074,16 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesWaitExternalSemaphoreExp( "urBindlessImagesWaitExternalSemaphoreExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urBindlessImagesWaitExternalSemaphoreExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, + UR_FUNCTION_BINDLESS_IMAGES_WAIT_EXTERNAL_SEMAPHORE_EXP, ¶ms); + logger.info(" ---> urBindlessImagesWaitExternalSemaphoreExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnWaitExternalSemaphoreExp( hQueue, hSemaphore, hasWaitValue, waitValue, numEventsInWaitList, @@ -6885,12 +8093,14 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesWaitExternalSemaphoreExp( UR_FUNCTION_BINDLESS_IMAGES_WAIT_EXTERNAL_SEMAPHORE_EXP, "urBindlessImagesWaitExternalSemaphoreExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_BINDLESS_IMAGES_WAIT_EXTERNAL_SEMAPHORE_EXP, - ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, + UR_FUNCTION_BINDLESS_IMAGES_WAIT_EXTERNAL_SEMAPHORE_EXP, ¶ms); + logger.info( + " <--- urBindlessImagesWaitExternalSemaphoreExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -6936,8 +8146,16 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesSignalExternalSemaphoreExp( "urBindlessImagesSignalExternalSemaphoreExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urBindlessImagesSignalExternalSemaphoreExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, + UR_FUNCTION_BINDLESS_IMAGES_SIGNAL_EXTERNAL_SEMAPHORE_EXP, ¶ms); + logger.info(" ---> urBindlessImagesSignalExternalSemaphoreExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnSignalExternalSemaphoreExp( hQueue, hSemaphore, hasSignalValue, signalValue, numEventsInWaitList, @@ -6948,12 +8166,14 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesSignalExternalSemaphoreExp( "urBindlessImagesSignalExternalSemaphoreExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_BINDLESS_IMAGES_SIGNAL_EXTERNAL_SEMAPHORE_EXP, - ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, + UR_FUNCTION_BINDLESS_IMAGES_SIGNAL_EXTERNAL_SEMAPHORE_EXP, ¶ms); + logger.info( + " <--- urBindlessImagesSignalExternalSemaphoreExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -6982,8 +8202,15 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferCreateExp( "urCommandBufferCreateExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urCommandBufferCreateExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_COMMAND_BUFFER_CREATE_EXP, ¶ms); + logger.info(" ---> urCommandBufferCreateExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnCreateExp(hContext, hDevice, pCommandBufferDesc, phCommandBuffer); @@ -6992,11 +8219,12 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferCreateExp( "urCommandBufferCreateExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_COMMAND_BUFFER_CREATE_EXP, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_COMMAND_BUFFER_CREATE_EXP, ¶ms); + logger.info(" <--- urCommandBufferCreateExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -7020,8 +8248,15 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferRetainExp( "urCommandBufferRetainExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urCommandBufferRetainExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_COMMAND_BUFFER_RETAIN_EXP, ¶ms); + logger.info(" ---> urCommandBufferRetainExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnRetainExp(hCommandBuffer); @@ -7029,11 +8264,12 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferRetainExp( "urCommandBufferRetainExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_COMMAND_BUFFER_RETAIN_EXP, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_COMMAND_BUFFER_RETAIN_EXP, ¶ms); + logger.info(" <--- urCommandBufferRetainExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -7058,8 +8294,15 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferReleaseExp( "urCommandBufferReleaseExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urCommandBufferReleaseExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_COMMAND_BUFFER_RELEASE_EXP, ¶ms); + logger.info(" ---> urCommandBufferReleaseExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnReleaseExp(hCommandBuffer); @@ -7067,11 +8310,12 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferReleaseExp( "urCommandBufferReleaseExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_COMMAND_BUFFER_RELEASE_EXP, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_COMMAND_BUFFER_RELEASE_EXP, ¶ms); + logger.info(" <--- urCommandBufferReleaseExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -7096,8 +8340,15 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferFinalizeExp( "urCommandBufferFinalizeExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urCommandBufferFinalizeExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_COMMAND_BUFFER_FINALIZE_EXP, ¶ms); + logger.info(" ---> urCommandBufferFinalizeExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnFinalizeExp(hCommandBuffer); @@ -7105,11 +8356,12 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferFinalizeExp( "urCommandBufferFinalizeExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_COMMAND_BUFFER_FINALIZE_EXP, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_COMMAND_BUFFER_FINALIZE_EXP, ¶ms); + logger.info(" <--- urCommandBufferFinalizeExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -7161,8 +8413,16 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferAppendKernelLaunchExp( "urCommandBufferAppendKernelLaunchExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urCommandBufferAppendKernelLaunchExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, + UR_FUNCTION_COMMAND_BUFFER_APPEND_KERNEL_LAUNCH_EXP, ¶ms); + logger.info(" ---> urCommandBufferAppendKernelLaunchExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnAppendKernelLaunchExp( hCommandBuffer, hKernel, workDim, pGlobalWorkOffset, pGlobalWorkSize, @@ -7173,12 +8433,13 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferAppendKernelLaunchExp( UR_FUNCTION_COMMAND_BUFFER_APPEND_KERNEL_LAUNCH_EXP, "urCommandBufferAppendKernelLaunchExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_COMMAND_BUFFER_APPEND_KERNEL_LAUNCH_EXP, + args_str_after, UR_FUNCTION_COMMAND_BUFFER_APPEND_KERNEL_LAUNCH_EXP, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + logger.info(" <--- urCommandBufferAppendKernelLaunchExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -7215,8 +8476,16 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferAppendUSMMemcpyExp( "urCommandBufferAppendUSMMemcpyExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urCommandBufferAppendUSMMemcpyExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_COMMAND_BUFFER_APPEND_USM_MEMCPY_EXP, + ¶ms); + logger.info(" ---> urCommandBufferAppendUSMMemcpyExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnAppendUSMMemcpyExp(hCommandBuffer, pDst, pSrc, size, numSyncPointsInWaitList, @@ -7226,12 +8495,13 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferAppendUSMMemcpyExp( "urCommandBufferAppendUSMMemcpyExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_COMMAND_BUFFER_APPEND_USM_MEMCPY_EXP, + args_str_after, UR_FUNCTION_COMMAND_BUFFER_APPEND_USM_MEMCPY_EXP, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + logger.info(" <--- urCommandBufferAppendUSMMemcpyExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -7271,8 +8541,16 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferAppendUSMFillExp( "urCommandBufferAppendUSMFillExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urCommandBufferAppendUSMFillExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_COMMAND_BUFFER_APPEND_USM_FILL_EXP, + ¶ms); + logger.info(" ---> urCommandBufferAppendUSMFillExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnAppendUSMFillExp( hCommandBuffer, pMemory, pPattern, patternSize, size, @@ -7282,11 +8560,13 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferAppendUSMFillExp( "urCommandBufferAppendUSMFillExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_COMMAND_BUFFER_APPEND_USM_FILL_EXP, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_COMMAND_BUFFER_APPEND_USM_FILL_EXP, + ¶ms); + logger.info(" <--- urCommandBufferAppendUSMFillExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -7332,8 +8612,16 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferAppendMemBufferCopyExp( "urCommandBufferAppendMemBufferCopyExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urCommandBufferAppendMemBufferCopyExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, + UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_COPY_EXP, ¶ms); + logger.info(" ---> urCommandBufferAppendMemBufferCopyExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnAppendMemBufferCopyExp( hCommandBuffer, hSrcMem, hDstMem, srcOffset, dstOffset, size, @@ -7343,12 +8631,14 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferAppendMemBufferCopyExp( UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_COPY_EXP, "urCommandBufferAppendMemBufferCopyExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_COPY_EXP, - ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, + UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_COPY_EXP, ¶ms); + logger.info( + " <--- urCommandBufferAppendMemBufferCopyExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -7393,8 +8683,16 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferAppendMemBufferWriteExp( "urCommandBufferAppendMemBufferWriteExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urCommandBufferAppendMemBufferWriteExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, + UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_WRITE_EXP, ¶ms); + logger.info(" ---> urCommandBufferAppendMemBufferWriteExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnAppendMemBufferWriteExp( hCommandBuffer, hBuffer, offset, size, pSrc, numSyncPointsInWaitList, @@ -7404,12 +8702,14 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferAppendMemBufferWriteExp( UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_WRITE_EXP, "urCommandBufferAppendMemBufferWriteExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_WRITE_EXP, - ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, + UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_WRITE_EXP, ¶ms); + logger.info( + " <--- urCommandBufferAppendMemBufferWriteExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -7453,8 +8753,16 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferAppendMemBufferReadExp( "urCommandBufferAppendMemBufferReadExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urCommandBufferAppendMemBufferReadExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, + UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_READ_EXP, ¶ms); + logger.info(" ---> urCommandBufferAppendMemBufferReadExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnAppendMemBufferReadExp( hCommandBuffer, hBuffer, offset, size, pDst, numSyncPointsInWaitList, @@ -7464,12 +8772,14 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferAppendMemBufferReadExp( UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_READ_EXP, "urCommandBufferAppendMemBufferReadExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_READ_EXP, - ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, + UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_READ_EXP, ¶ms); + logger.info( + " <--- urCommandBufferAppendMemBufferReadExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -7526,8 +8836,17 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferAppendMemBufferCopyRectExp( "urCommandBufferAppendMemBufferCopyRectExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urCommandBufferAppendMemBufferCopyRectExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, + UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_COPY_RECT_EXP, + ¶ms); + logger.info(" ---> urCommandBufferAppendMemBufferCopyRectExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnAppendMemBufferCopyRectExp( hCommandBuffer, hSrcMem, hDstMem, srcOrigin, dstOrigin, region, @@ -7539,13 +8858,15 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferAppendMemBufferCopyRectExp( "urCommandBufferAppendMemBufferCopyRectExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, + args_str_after, UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_COPY_RECT_EXP, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + logger.info( + " <--- urCommandBufferAppendMemBufferCopyRectExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -7609,8 +8930,17 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferAppendMemBufferWriteRectExp( "urCommandBufferAppendMemBufferWriteRectExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urCommandBufferAppendMemBufferWriteRectExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, + UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_WRITE_RECT_EXP, + ¶ms); + logger.info(" ---> urCommandBufferAppendMemBufferWriteRectExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnAppendMemBufferWriteRectExp( hCommandBuffer, hBuffer, bufferOffset, hostOffset, region, @@ -7622,13 +8952,15 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferAppendMemBufferWriteRectExp( "urCommandBufferAppendMemBufferWriteRectExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, + args_str_after, UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_WRITE_RECT_EXP, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + logger.info( + " <--- urCommandBufferAppendMemBufferWriteRectExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -7689,8 +9021,17 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferAppendMemBufferReadRectExp( "urCommandBufferAppendMemBufferReadRectExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urCommandBufferAppendMemBufferReadRectExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, + UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_READ_RECT_EXP, + ¶ms); + logger.info(" ---> urCommandBufferAppendMemBufferReadRectExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnAppendMemBufferReadRectExp( hCommandBuffer, hBuffer, bufferOffset, hostOffset, region, @@ -7702,13 +9043,15 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferAppendMemBufferReadRectExp( "urCommandBufferAppendMemBufferReadRectExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, + args_str_after, UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_READ_RECT_EXP, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + logger.info( + " <--- urCommandBufferAppendMemBufferReadRectExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -7755,8 +9098,16 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferAppendMemBufferFillExp( "urCommandBufferAppendMemBufferFillExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urCommandBufferAppendMemBufferFillExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, + UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_FILL_EXP, ¶ms); + logger.info(" ---> urCommandBufferAppendMemBufferFillExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnAppendMemBufferFillExp( hCommandBuffer, hBuffer, pPattern, patternSize, offset, size, @@ -7766,12 +9117,14 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferAppendMemBufferFillExp( UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_FILL_EXP, "urCommandBufferAppendMemBufferFillExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_FILL_EXP, - ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, + UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_FILL_EXP, ¶ms); + logger.info( + " <--- urCommandBufferAppendMemBufferFillExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -7813,8 +9166,16 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferAppendUSMPrefetchExp( "urCommandBufferAppendUSMPrefetchExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urCommandBufferAppendUSMPrefetchExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_COMMAND_BUFFER_APPEND_USM_PREFETCH_EXP, + ¶ms); + logger.info(" ---> urCommandBufferAppendUSMPrefetchExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnAppendUSMPrefetchExp( hCommandBuffer, pMemory, size, flags, numSyncPointsInWaitList, @@ -7824,12 +9185,13 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferAppendUSMPrefetchExp( "urCommandBufferAppendUSMPrefetchExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_COMMAND_BUFFER_APPEND_USM_PREFETCH_EXP, + args_str_after, UR_FUNCTION_COMMAND_BUFFER_APPEND_USM_PREFETCH_EXP, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + logger.info(" <--- urCommandBufferAppendUSMPrefetchExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -7871,8 +9233,16 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferAppendUSMAdviseExp( "urCommandBufferAppendUSMAdviseExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urCommandBufferAppendUSMAdviseExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_COMMAND_BUFFER_APPEND_USM_ADVISE_EXP, + ¶ms); + logger.info(" ---> urCommandBufferAppendUSMAdviseExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnAppendUSMAdviseExp(hCommandBuffer, pMemory, size, advice, numSyncPointsInWaitList, @@ -7882,12 +9252,13 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferAppendUSMAdviseExp( "urCommandBufferAppendUSMAdviseExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_COMMAND_BUFFER_APPEND_USM_ADVISE_EXP, + args_str_after, UR_FUNCTION_COMMAND_BUFFER_APPEND_USM_ADVISE_EXP, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + logger.info(" <--- urCommandBufferAppendUSMAdviseExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -7924,8 +9295,15 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferEnqueueExp( "urCommandBufferEnqueueExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urCommandBufferEnqueueExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_COMMAND_BUFFER_ENQUEUE_EXP, ¶ms); + logger.info(" ---> urCommandBufferEnqueueExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnEnqueueExp( hCommandBuffer, hQueue, numEventsInWaitList, phEventWaitList, phEvent); @@ -7934,11 +9312,12 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferEnqueueExp( "urCommandBufferEnqueueExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_COMMAND_BUFFER_ENQUEUE_EXP, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_COMMAND_BUFFER_ENQUEUE_EXP, ¶ms); + logger.info(" <--- urCommandBufferEnqueueExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -7963,8 +9342,16 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferRetainCommandExp( "urCommandBufferRetainCommandExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urCommandBufferRetainCommandExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_COMMAND_BUFFER_RETAIN_COMMAND_EXP, + ¶ms); + logger.info(" ---> urCommandBufferRetainCommandExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnRetainCommandExp(hCommand); @@ -7972,11 +9359,13 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferRetainCommandExp( "urCommandBufferRetainCommandExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_COMMAND_BUFFER_RETAIN_COMMAND_EXP, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_COMMAND_BUFFER_RETAIN_COMMAND_EXP, + ¶ms); + logger.info(" <--- urCommandBufferRetainCommandExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -8001,8 +9390,16 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferReleaseCommandExp( "urCommandBufferReleaseCommandExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urCommandBufferReleaseCommandExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_COMMAND_BUFFER_RELEASE_COMMAND_EXP, + ¶ms); + logger.info(" ---> urCommandBufferReleaseCommandExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnReleaseCommandExp(hCommand); @@ -8010,11 +9407,13 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferReleaseCommandExp( "urCommandBufferReleaseCommandExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_COMMAND_BUFFER_RELEASE_COMMAND_EXP, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_COMMAND_BUFFER_RELEASE_COMMAND_EXP, + ¶ms); + logger.info(" <--- urCommandBufferReleaseCommandExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -8042,8 +9441,16 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferUpdateKernelLaunchExp( "urCommandBufferUpdateKernelLaunchExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urCommandBufferUpdateKernelLaunchExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, + UR_FUNCTION_COMMAND_BUFFER_UPDATE_KERNEL_LAUNCH_EXP, ¶ms); + logger.info(" ---> urCommandBufferUpdateKernelLaunchExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnUpdateKernelLaunchExp(hCommand, pUpdateKernelLaunch); @@ -8052,12 +9459,13 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferUpdateKernelLaunchExp( UR_FUNCTION_COMMAND_BUFFER_UPDATE_KERNEL_LAUNCH_EXP, "urCommandBufferUpdateKernelLaunchExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_COMMAND_BUFFER_UPDATE_KERNEL_LAUNCH_EXP, + args_str_after, UR_FUNCTION_COMMAND_BUFFER_UPDATE_KERNEL_LAUNCH_EXP, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + logger.info(" <--- urCommandBufferUpdateKernelLaunchExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -8092,8 +9500,15 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferGetInfoExp( "urCommandBufferGetInfoExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urCommandBufferGetInfoExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_COMMAND_BUFFER_GET_INFO_EXP, ¶ms); + logger.info(" ---> urCommandBufferGetInfoExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnGetInfoExp(hCommandBuffer, propName, propSize, pPropValue, pPropSizeRet); @@ -8102,11 +9517,12 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferGetInfoExp( "urCommandBufferGetInfoExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_COMMAND_BUFFER_GET_INFO_EXP, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_COMMAND_BUFFER_GET_INFO_EXP, ¶ms); + logger.info(" <--- urCommandBufferGetInfoExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -8141,8 +9557,16 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferCommandGetInfoExp( "urCommandBufferCommandGetInfoExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urCommandBufferCommandGetInfoExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_COMMAND_BUFFER_COMMAND_GET_INFO_EXP, + ¶ms); + logger.info(" ---> urCommandBufferCommandGetInfoExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnCommandGetInfoExp(hCommand, propName, propSize, pPropValue, pPropSizeRet); @@ -8151,11 +9575,13 @@ __urdlllocal ur_result_t UR_APICALL urCommandBufferCommandGetInfoExp( "urCommandBufferCommandGetInfoExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_COMMAND_BUFFER_COMMAND_GET_INFO_EXP, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_COMMAND_BUFFER_COMMAND_GET_INFO_EXP, + ¶ms); + logger.info(" <--- urCommandBufferCommandGetInfoExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -8214,8 +9640,16 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueCooperativeKernelLaunchExp( "urEnqueueCooperativeKernelLaunchExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urEnqueueCooperativeKernelLaunchExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_ENQUEUE_COOPERATIVE_KERNEL_LAUNCH_EXP, + ¶ms); + logger.info(" ---> urEnqueueCooperativeKernelLaunchExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnCooperativeKernelLaunchExp( hQueue, hKernel, workDim, pGlobalWorkOffset, pGlobalWorkSize, @@ -8225,12 +9659,13 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueCooperativeKernelLaunchExp( "urEnqueueCooperativeKernelLaunchExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ENQUEUE_COOPERATIVE_KERNEL_LAUNCH_EXP, + args_str_after, UR_FUNCTION_ENQUEUE_COOPERATIVE_KERNEL_LAUNCH_EXP, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + logger.info(" <--- urEnqueueCooperativeKernelLaunchExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -8263,8 +9698,17 @@ __urdlllocal ur_result_t UR_APICALL urKernelSuggestMaxCooperativeGroupCountExp( "urKernelSuggestMaxCooperativeGroupCountExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urKernelSuggestMaxCooperativeGroupCountExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, + UR_FUNCTION_KERNEL_SUGGEST_MAX_COOPERATIVE_GROUP_COUNT_EXP, + ¶ms); + logger.info(" ---> urKernelSuggestMaxCooperativeGroupCountExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnSuggestMaxCooperativeGroupCountExp( hKernel, localWorkSize, dynamicSharedMemorySize, pGroupCountRet); @@ -8274,13 +9718,15 @@ __urdlllocal ur_result_t UR_APICALL urKernelSuggestMaxCooperativeGroupCountExp( "urKernelSuggestMaxCooperativeGroupCountExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, + args_str_after, UR_FUNCTION_KERNEL_SUGGEST_MAX_COOPERATIVE_GROUP_COUNT_EXP, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + logger.info( + " <--- urKernelSuggestMaxCooperativeGroupCountExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -8323,8 +9769,16 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueTimestampRecordingExp( "urEnqueueTimestampRecordingExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urEnqueueTimestampRecordingExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_ENQUEUE_TIMESTAMP_RECORDING_EXP, + ¶ms); + logger.info(" ---> urEnqueueTimestampRecordingExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnTimestampRecordingExp( hQueue, blocking, numEventsInWaitList, phEventWaitList, phEvent); @@ -8333,11 +9787,13 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueTimestampRecordingExp( "urEnqueueTimestampRecordingExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ENQUEUE_TIMESTAMP_RECORDING_EXP, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_ENQUEUE_TIMESTAMP_RECORDING_EXP, + ¶ms); + logger.info(" <--- urEnqueueTimestampRecordingExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -8391,8 +9847,16 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueKernelLaunchCustomExp( "urEnqueueKernelLaunchCustomExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urEnqueueKernelLaunchCustomExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_ENQUEUE_KERNEL_LAUNCH_CUSTOM_EXP, + ¶ms); + logger.info(" ---> urEnqueueKernelLaunchCustomExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnKernelLaunchCustomExp( hQueue, hKernel, workDim, pGlobalWorkSize, pLocalWorkSize, @@ -8403,11 +9867,13 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueKernelLaunchCustomExp( "urEnqueueKernelLaunchCustomExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ENQUEUE_KERNEL_LAUNCH_CUSTOM_EXP, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_ENQUEUE_KERNEL_LAUNCH_CUSTOM_EXP, + ¶ms); + logger.info(" <--- urEnqueueKernelLaunchCustomExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -8435,19 +9901,26 @@ __urdlllocal ur_result_t UR_APICALL urProgramBuildExp( UR_FUNCTION_PROGRAM_BUILD_EXP, "urProgramBuildExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urProgramBuildExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_PROGRAM_BUILD_EXP, ¶ms); + logger.info(" ---> urProgramBuildExp({})\n", args_str_before.str()); + } ur_result_t result = pfnBuildExp(hProgram, numDevices, phDevices, pOptions); getContext()->notify_end(UR_FUNCTION_PROGRAM_BUILD_EXP, "urProgramBuildExp", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_PROGRAM_BUILD_EXP, ¶ms); + logger.info(" <--- urProgramBuildExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -8476,8 +9949,14 @@ __urdlllocal ur_result_t UR_APICALL urProgramCompileExp( UR_FUNCTION_PROGRAM_COMPILE_EXP, "urProgramCompileExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urProgramCompileExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_PROGRAM_COMPILE_EXP, ¶ms); + logger.info(" ---> urProgramCompileExp({})\n", args_str_before.str()); + } ur_result_t result = pfnCompileExp(hProgram, numDevices, phDevices, pOptions); @@ -8485,11 +9964,12 @@ __urdlllocal ur_result_t UR_APICALL urProgramCompileExp( getContext()->notify_end(UR_FUNCTION_PROGRAM_COMPILE_EXP, "urProgramCompileExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_PROGRAM_COMPILE_EXP, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_PROGRAM_COMPILE_EXP, ¶ms); + logger.info(" <--- urProgramCompileExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -8526,8 +10006,14 @@ __urdlllocal ur_result_t UR_APICALL urProgramLinkExp( "urProgramLinkExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urProgramLinkExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_PROGRAM_LINK_EXP, ¶ms); + logger.info(" ---> urProgramLinkExp({})\n", args_str_before.str()); + } ur_result_t result = pfnLinkExp(hContext, numDevices, phDevices, count, phPrograms, pOptions, phProgram); @@ -8535,11 +10021,12 @@ __urdlllocal ur_result_t UR_APICALL urProgramLinkExp( getContext()->notify_end(UR_FUNCTION_PROGRAM_LINK_EXP, "urProgramLinkExp", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_PROGRAM_LINK_EXP, ¶ms); + logger.info(" <--- urProgramLinkExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -8563,19 +10050,26 @@ __urdlllocal ur_result_t UR_APICALL urUSMImportExp( "urUSMImportExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urUSMImportExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_USM_IMPORT_EXP, ¶ms); + logger.info(" ---> urUSMImportExp({})\n", args_str_before.str()); + } ur_result_t result = pfnImportExp(hContext, pMem, size); getContext()->notify_end(UR_FUNCTION_USM_IMPORT_EXP, "urUSMImportExp", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_USM_IMPORT_EXP, ¶ms); + logger.info(" <--- urUSMImportExp({}) -> {};\n", args_str_after.str(), + result); } return result; @@ -8598,19 +10092,26 @@ __urdlllocal ur_result_t UR_APICALL urUSMReleaseExp( "urUSMReleaseExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urUSMReleaseExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams(args_str_before, + UR_FUNCTION_USM_RELEASE_EXP, ¶ms); + logger.info(" ---> urUSMReleaseExp({})\n", args_str_before.str()); + } ur_result_t result = pfnReleaseExp(hContext, pMem); getContext()->notify_end(UR_FUNCTION_USM_RELEASE_EXP, "urUSMReleaseExp", ¶ms, &result, instance); - 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); + if (should_log) { + std::ostringstream args_str_after; + ur::extras::printFunctionParams(args_str_after, + UR_FUNCTION_USM_RELEASE_EXP, ¶ms); + logger.info(" <--- urUSMReleaseExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -8637,8 +10138,16 @@ __urdlllocal ur_result_t UR_APICALL urUsmP2PEnablePeerAccessExp( "urUsmP2PEnablePeerAccessExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urUsmP2PEnablePeerAccessExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_USM_P2P_ENABLE_PEER_ACCESS_EXP, + ¶ms); + logger.info(" ---> urUsmP2PEnablePeerAccessExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnEnablePeerAccessExp(commandDevice, peerDevice); @@ -8646,11 +10155,13 @@ __urdlllocal ur_result_t UR_APICALL urUsmP2PEnablePeerAccessExp( "urUsmP2PEnablePeerAccessExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_USM_P2P_ENABLE_PEER_ACCESS_EXP, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_USM_P2P_ENABLE_PEER_ACCESS_EXP, + ¶ms); + logger.info(" <--- urUsmP2PEnablePeerAccessExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -8677,8 +10188,16 @@ __urdlllocal ur_result_t UR_APICALL urUsmP2PDisablePeerAccessExp( "urUsmP2PDisablePeerAccessExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urUsmP2PDisablePeerAccessExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_USM_P2P_DISABLE_PEER_ACCESS_EXP, + ¶ms); + logger.info(" ---> urUsmP2PDisablePeerAccessExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnDisablePeerAccessExp(commandDevice, peerDevice); @@ -8686,11 +10205,13 @@ __urdlllocal ur_result_t UR_APICALL urUsmP2PDisablePeerAccessExp( "urUsmP2PDisablePeerAccessExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_USM_P2P_DISABLE_PEER_ACCESS_EXP, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_USM_P2P_DISABLE_PEER_ACCESS_EXP, + ¶ms); + logger.info(" <--- urUsmP2PDisablePeerAccessExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -8729,8 +10250,16 @@ __urdlllocal ur_result_t UR_APICALL urUsmP2PPeerAccessGetInfoExp( "urUsmP2PPeerAccessGetInfoExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urUsmP2PPeerAccessGetInfoExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_USM_P2P_PEER_ACCESS_GET_INFO_EXP, + ¶ms); + logger.info(" ---> urUsmP2PPeerAccessGetInfoExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnPeerAccessGetInfoExp(commandDevice, peerDevice, propName, propSize, @@ -8740,11 +10269,13 @@ __urdlllocal ur_result_t UR_APICALL urUsmP2PPeerAccessGetInfoExp( "urUsmP2PPeerAccessGetInfoExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_USM_P2P_PEER_ACCESS_GET_INFO_EXP, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_USM_P2P_PEER_ACCESS_GET_INFO_EXP, + ¶ms); + logger.info(" <--- urUsmP2PPeerAccessGetInfoExp({}) -> {};\n", + args_str_after.str(), result); } return result; @@ -8796,8 +10327,15 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueNativeCommandExp( "urEnqueueNativeCommandExp", ¶ms); auto &logger = getContext()->logger; + const bool should_log = (logger.getLevel() <= logger::Level::INFO); - logger.info("---> urEnqueueNativeCommandExp"); + if (should_log) { + std::ostringstream args_str_before; + ur::extras::printFunctionParams( + args_str_before, UR_FUNCTION_ENQUEUE_NATIVE_COMMAND_EXP, ¶ms); + logger.info(" ---> urEnqueueNativeCommandExp({})\n", + args_str_before.str()); + } ur_result_t result = pfnNativeCommandExp( hQueue, pfnNativeEnqueue, data, numMemsInMemList, phMemList, @@ -8807,11 +10345,12 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueNativeCommandExp( "urEnqueueNativeCommandExp", ¶ms, &result, instance); - if (logger.getLevel() <= logger::Level::INFO) { - std::ostringstream args_str; + if (should_log) { + std::ostringstream args_str_after; ur::extras::printFunctionParams( - args_str, UR_FUNCTION_ENQUEUE_NATIVE_COMMAND_EXP, ¶ms); - logger.info("({}) -> {};\n", args_str.str(), result); + args_str_after, UR_FUNCTION_ENQUEUE_NATIVE_COMMAND_EXP, ¶ms); + logger.info(" <--- urEnqueueNativeCommandExp({}) -> {};\n", + args_str_after.str(), result); } return result; diff --git a/test/layers/tracing/hello_world.out.logged.match b/test/layers/tracing/hello_world.out.logged.match index 99b9cac909..40d579258c 100644 --- a/test/layers/tracing/hello_world.out.logged.match +++ b/test/layers/tracing/hello_world.out.logged.match @@ -1,13 +1,23 @@ Platform initialized. ----> urAdapterGet(.NumEntries = 0, .phAdapters = {{.*}}, .pNumAdapters = {{.*}} (1)) -> UR_RESULT_SUCCESS; ----> urAdapterGet(.NumEntries = 1, .phAdapters = {{.*}}, .pNumAdapters = nullptr) -> UR_RESULT_SUCCESS; ----> urPlatformGet(.phAdapters = {{.*}}, .NumAdapters = 1, .NumEntries = 1, .phPlatforms = {{.*}}, .pNumPlatforms = {{.*}} (1)) -> UR_RESULT_SUCCESS; ----> urPlatformGet(.phAdapters = {{.*}}, .NumAdapters = 1, .NumEntries = 1, .phPlatforms = {{.*}}, .pNumPlatforms = nullptr) -> UR_RESULT_SUCCESS; ----> urPlatformGetApiVersion(.hPlatform = {{.*}}, .pVersion = {{.*}} ({{0\.[0-9]+}})) -> UR_RESULT_SUCCESS; + ---> urAdapterGet(.NumEntries = 0, .phAdapters = {{.*}}, .pNumAdapters = {{.*}} (0)) + <--- urAdapterGet(.NumEntries = 0, .phAdapters = {{.*}}, .pNumAdapters = {{.*}} (1)) -> UR_RESULT_SUCCESS; + ---> urAdapterGet(.NumEntries = 1, .phAdapters = {{.*}}, .pNumAdapters = nullptr) + <--- urAdapterGet(.NumEntries = 1, .phAdapters = {{.*}}, .pNumAdapters = nullptr) -> UR_RESULT_SUCCESS; + ---> urPlatformGet(.phAdapters = {{.*}}, .NumAdapters = 1, .NumEntries = 1, .phPlatforms = {{.*}}, .pNumPlatforms = {{.*}} (0)) + <--- urPlatformGet(.phAdapters = {{.*}}, .NumAdapters = 1, .NumEntries = 1, .phPlatforms = {{.*}}, .pNumPlatforms = {{.*}} (1)) -> UR_RESULT_SUCCESS; + ---> urPlatformGet(.phAdapters = {{.*}}, .NumAdapters = 1, .NumEntries = 1, .phPlatforms = {{.*}}, .pNumPlatforms = nullptr) + <--- urPlatformGet(.phAdapters = {{.*}}, .NumAdapters = 1, .NumEntries = 1, .phPlatforms = {{.*}}, .pNumPlatforms = nullptr) -> UR_RESULT_SUCCESS; + ---> urPlatformGetApiVersion(.hPlatform = {{.*}}, .pVersion = {{.*}} ({{0\.[0-9]+}})) + <--- urPlatformGetApiVersion(.hPlatform = {{.*}}, .pVersion = {{.*}} ({{0\.[0-9]+}})) -> UR_RESULT_SUCCESS; API version: {{0\.[0-9]+}} ----> urDeviceGet(.hPlatform = {{.*}}, .DeviceType = UR_DEVICE_TYPE_GPU, .NumEntries = 0, .phDevices = {}, .pNumDevices = {{.*}} (1)) -> UR_RESULT_SUCCESS; ----> urDeviceGet(.hPlatform = {{.*}}, .DeviceType = UR_DEVICE_TYPE_GPU, .NumEntries = 1, .phDevices = {{.*}}, .pNumDevices = nullptr) -> UR_RESULT_SUCCESS; ----> urDeviceGetInfo(.hDevice = {{.*}}, .propName = UR_DEVICE_INFO_TYPE, .propSize = 4, .pPropValue = {{.*}} (UR_DEVICE_TYPE_GPU), .pPropSizeRet = nullptr) -> UR_RESULT_SUCCESS; ----> urDeviceGetInfo(.hDevice = {{.*}}, .propName = UR_DEVICE_INFO_NAME, .propSize = {{.*}}, .pPropValue = {{.*}} (Mock Device), .pPropSizeRet = nullptr) -> UR_RESULT_SUCCESS; + ---> urDeviceGet(.hPlatform = {{.*}}, .DeviceType = UR_DEVICE_TYPE_GPU, .NumEntries = 0, .phDevices = {}, .pNumDevices = {{.*}} (0)) + <--- urDeviceGet(.hPlatform = {{.*}}, .DeviceType = UR_DEVICE_TYPE_GPU, .NumEntries = 0, .phDevices = {}, .pNumDevices = {{.*}} (1)) -> UR_RESULT_SUCCESS; + ---> urDeviceGet(.hPlatform = {{.*}}, .DeviceType = UR_DEVICE_TYPE_GPU, .NumEntries = 1, .phDevices = {{.*}}, .pNumDevices = nullptr) + <--- urDeviceGet(.hPlatform = {{.*}}, .DeviceType = UR_DEVICE_TYPE_GPU, .NumEntries = 1, .phDevices = {{.*}}, .pNumDevices = nullptr) -> UR_RESULT_SUCCESS; + ---> urDeviceGetInfo(.hDevice = {{.*}}, .propName = UR_DEVICE_INFO_TYPE, .propSize = 4, .pPropValue = {{.*}} (UR_DEVICE_TYPE_ALL), .pPropSizeRet = nullptr) + <--- urDeviceGetInfo(.hDevice = {{.*}}, .propName = UR_DEVICE_INFO_TYPE, .propSize = 4, .pPropValue = {{.*}} (UR_DEVICE_TYPE_GPU), .pPropSizeRet = nullptr) -> UR_RESULT_SUCCESS; + ---> urDeviceGetInfo(.hDevice = {{.*}}, .propName = UR_DEVICE_INFO_NAME, .propSize = {{.*}}, .pPropValue = {{.*}} (), .pPropSizeRet = nullptr) + <--- urDeviceGetInfo(.hDevice = {{.*}}, .propName = UR_DEVICE_INFO_NAME, .propSize = {{.*}}, .pPropValue = {{.*}} (Mock Device), .pPropSizeRet = nullptr) -> UR_RESULT_SUCCESS; Found a Mock Device gpu. ----> urAdapterRelease(.hAdapter = {{.*}}) -> UR_RESULT_SUCCESS; + ---> urAdapterRelease(.hAdapter = {{.*}}) + <--- urAdapterRelease(.hAdapter = {{.*}}) -> UR_RESULT_SUCCESS;