Skip to content

Commit 20d14b5

Browse files
nrspruitnrspruit
committed
feature: Add zelGetTracingLayerState to query if tracing is enabled
Signed-off-by: Neil R. Spruit <neil.r.spruit@intel.com>
1 parent 5172a58 commit 20d14b5

File tree

5 files changed

+319
-0
lines changed

5 files changed

+319
-0
lines changed

‎doc/loader_api.md‎

Lines changed: 14 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -50,3 +50,17 @@ Disables the tracing layer intercepts at runtime by restoring the previous call
5050
This does not unload the tracing layer library such that one can call `zelEnableTracingLayer` and `zelDisableTracingLayer` as many times one needs to during the application.
5151

5252
NOTE: The each call to `zelEnableTracingLayer` tracks a reference count of how many calls to enable have been seen. The Tracing Layer intercepts will not be removed until the reference count has reached 0 indicating that all users of the tracing layer have called `zelDisableTracingLayer`.
53+
54+
### zelGetTracingLayerState
55+
56+
Queries the current enabled state of the tracing layer at runtime.
57+
58+
This function allows applications to check whether the tracing layer is currently active, returning the state through a boolean pointer.
59+
60+
- __*enabled__ Pointer to a boolean that will be set to `true` if the tracing layer is currently enabled, or `false` if it is disabled.
61+
62+
The function returns:
63+
- `ZE_RESULT_SUCCESS` on successful query
64+
- `ZE_RESULT_ERROR_INVALID_NULL_POINTER` if the `enabled` pointer is null
65+
66+
This is a read-only, thread-safe operation that can be called multiple times concurrently. The tracing layer state is global to the process and reflects the current reference count maintained by `zelEnableTracingLayer` and `zelDisableTracingLayer` - the layer is considered enabled when the reference count is greater than zero.

‎include/loader/ze_loader.h‎

Lines changed: 22 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -135,6 +135,28 @@ zelRegisterTeardownCallback(
135135
ZE_DLLEXPORT ze_result_t ZE_APICALL
136136
zelDisableTracingLayer();
137137

138+
/**
139+
* @brief Retrieves the current enabled state of the Level Zero tracing layer.
140+
*
141+
* This function queries whether the tracing layer is active and writes the result
142+
* to the provided boolean pointer.
143+
*
144+
* @param enabled
145+
* Pointer to a boolean that will be set to true if the tracing layer is
146+
* currently enabled, or false if it is disabled. Must be a valid, non-null
147+
* pointer.
148+
*
149+
* @return
150+
* ZE_RESULT_SUCCESS on success.
151+
* ZE_RESULT_ERROR_INVALID_NULL_POINTER if `enabled` is null.
152+
* Other ze_result_t error codes may be returned for implementation-specific failures.
153+
*
154+
* @note The tracing layer state is global to the process. The function is read-only
155+
* and thread-safe; multiple callers can query the state concurrently.
156+
*/
157+
ZE_DLLEXPORT ze_result_t ZE_APICALL
158+
zelGetTracingLayerState(bool* enabled); // Pointer to bool to receive tracing layer state
159+
138160
#if defined(__cplusplus)
139161
} // extern "C"
140162
#endif

‎source/lib/ze_lib.cpp‎

Lines changed: 30 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -587,6 +587,36 @@ zelEnableTracingLayer()
587587
return ZE_RESULT_SUCCESS;
588588
}
589589

590+
ze_result_t ZE_APICALL
591+
zelGetTracingLayerState
592+
(
593+
bool* enabled // Pointer to bool to receive tracing layer state
594+
)
595+
{
596+
if (enabled == nullptr) {
597+
return ZE_RESULT_ERROR_INVALID_NULL_POINTER;
598+
}
599+
#ifdef L0_STATIC_LOADER_BUILD
600+
if(nullptr == ze_lib::context->loader)
601+
return ZE_RESULT_ERROR_UNINITIALIZED;
602+
typedef ze_result_t (ZE_APICALL *zelGetTracingLayerStateInternal_t)(bool* enabled);
603+
auto getDynamicTracingState = reinterpret_cast<zelGetTracingLayerStateInternal_t>(
604+
GET_FUNCTION_PTR(ze_lib::context->loader, "zelGetTracingLayerState") );
605+
return getDynamicTracingState(enabled);
606+
#else
607+
if (ze_lib::context->dynamicTracingSupported == false) {
608+
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
609+
}
610+
if (loader::context) {
611+
*enabled = loader::context->tracingLayerEnabled;
612+
}
613+
if (!*enabled) {
614+
*enabled = (ze_lib::context->tracingLayerEnableCounter.load() > 0);
615+
}
616+
#endif
617+
return ZE_RESULT_SUCCESS;
618+
}
619+
590620
ze_result_t ZE_APICALL
591621
zelDisableTracingLayer()
592622
{

‎test/CMakeLists.txt‎

Lines changed: 38 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -191,6 +191,42 @@ endif()
191191
add_test(NAME tests_loader_teardown_check COMMAND tests --gtest_filter=*GivenLoaderNotInDestructionStateWhenCallingzelCheckIsLoaderInTearDownThenFalseIsReturned)
192192
set_property(TEST tests_loader_teardown_check PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_NULL_DRIVER=1")
193193

194+
add_test(NAME tests_tracing_layer_state_null_pointer COMMAND tests --gtest_filter=*TracingLayerState.GivenNullPointerWhenCallingzelGetTracingLayerStateThenErrorInvalidNullPointerIsReturned)
195+
set_property(TEST tests_tracing_layer_state_null_pointer PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_NULL_DRIVER=1")
196+
197+
add_test(NAME tests_tracing_layer_state_valid_pointer COMMAND tests --gtest_filter=*TracingLayerState.GivenValidPointerWhenCallingzelGetTracingLayerStateThenSuccessIsReturned)
198+
set_property(TEST tests_tracing_layer_state_valid_pointer PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_NULL_DRIVER=1")
199+
200+
add_test(NAME tests_tracing_layer_state_not_enabled COMMAND tests --gtest_filter=*TracingLayerState.GivenTracingLayerNotEnabledWhenCallingzelGetTracingLayerStateThenFalseIsReturned)
201+
set_property(TEST tests_tracing_layer_state_not_enabled PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_NULL_DRIVER=1")
202+
203+
add_test(NAME tests_tracing_layer_state_enabled COMMAND tests --gtest_filter=*TracingLayerState.GivenTracingLayerEnabledWhenCallingzelGetTracingLayerStateThenTrueIsReturned)
204+
set_property(TEST tests_tracing_layer_state_enabled PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_NULL_DRIVER=1")
205+
206+
add_test(NAME tests_tracing_layer_state_enabled_then_disabled COMMAND tests --gtest_filter=*TracingLayerState.GivenTracingLayerEnabledThenDisabledWhenCallingzelGetTracingLayerStateThenFalseIsReturned)
207+
set_property(TEST tests_tracing_layer_state_enabled_then_disabled PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_NULL_DRIVER=1")
208+
209+
add_test(NAME tests_tracing_layer_state_multiple_enable COMMAND tests --gtest_filter=*TracingLayerState.GivenMultipleEnableCallsWhenCallingzelGetTracingLayerStateThenTrueIsReturned)
210+
set_property(TEST tests_tracing_layer_state_multiple_enable PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_NULL_DRIVER=1")
211+
212+
add_test(NAME tests_tracing_layer_state_multiple_enable_partial_disable COMMAND tests --gtest_filter=*TracingLayerState.GivenMultipleEnableAndPartialDisableWhenCallingzelGetTracingLayerStateThenTrueIsReturned)
213+
set_property(TEST tests_tracing_layer_state_multiple_enable_partial_disable PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_NULL_DRIVER=1")
214+
215+
add_test(NAME tests_tracing_layer_state_multiple_calls_enabled COMMAND tests --gtest_filter=*TracingLayerState.GivenMultipleCallsTozelGetTracingLayerStateWhenTracingEnabledThenAllReturnTrue)
216+
set_property(TEST tests_tracing_layer_state_multiple_calls_enabled PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_NULL_DRIVER=1")
217+
218+
add_test(NAME tests_tracing_layer_state_multiple_calls_disabled COMMAND tests --gtest_filter=*TracingLayerState.GivenMultipleCallsTozelGetTracingLayerStateWhenTracingDisabledThenAllReturnFalse)
219+
set_property(TEST tests_tracing_layer_state_multiple_calls_disabled PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_NULL_DRIVER=1")
220+
221+
add_test(NAME tests_tracing_layer_state_enabled_via_environment COMMAND tests --gtest_filter=*TracingLayerState.GivenTracingLayerEnabledViaEnvironmentWhenCallingzelGetTracingLayerStateThenTrueIsReturned)
222+
set_property(TEST tests_tracing_layer_state_enabled_via_environment PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_NULL_DRIVER=1")
223+
224+
add_test(NAME tests_tracing_layer_state_enabled_via_environment_and_dynamic COMMAND tests --gtest_filter=*TracingLayerState.GivenTracingLayerEnabledViaEnvironmentWhenCallingzelEnableTracingLayerThenStateRemainsTrue)
225+
set_property(TEST tests_tracing_layer_state_enabled_via_environment_and_dynamic PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_NULL_DRIVER=1")
226+
227+
add_test(NAME tests_tracing_layer_state_enabled_via_environment_disable_dynamic COMMAND tests --gtest_filter=*TracingLayerState.GivenTracingLayerEnabledViaEnvironmentAndDynamicallyWhenDisablingDynamicTracingThenStateRemainsTrue)
228+
set_property(TEST tests_tracing_layer_state_enabled_via_environment_disable_dynamic PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_NULL_DRIVER=1")
229+
194230
add_test(NAME test_zello_world_legacy COMMAND zello_world --enable_legacy_init --enable_null_driver --force_loader_intercepts --enable_validation_layer --enable_tracing_layer --enable_tracing_layer_runtime)
195231
set_property(TEST test_zello_world_legacy PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1")
196232

@@ -650,6 +686,8 @@ else()
650686
set_property(TEST init_driver_unit_tests PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_NULL_DRIVER=1;")
651687
endif()
652688

689+
690+
653691
# These tests are currently not supported on Windows. The reason is that the std::cerr is not being redirected to a pipe in Windows to be then checked against the expected output.
654692
if(NOT MSVC)
655693
add_test(NAME tests_event_deadlock COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingzeCommandListAppendMemoryCopyWithCircularDependencyOnEventsThenValidationLayerPrintsWarningOfDeadlock*)

‎test/loader_api.cpp‎

Lines changed: 215 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -411,6 +411,221 @@ TEST(
411411
EXPECT_FALSE(zelCheckIsLoaderInTearDown());
412412
}
413413

414+
TEST(
415+
TracingLayerState,
416+
GivenNullPointerWhenCallingzelGetTracingLayerStateThenErrorInvalidNullPointerIsReturned) {
417+
418+
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_NULL_POINTER, zelGetTracingLayerState(nullptr));
419+
}
420+
421+
TEST(
422+
TracingLayerState,
423+
GivenValidPointerWhenCallingzelGetTracingLayerStateThenSuccessIsReturned) {
424+
425+
uint32_t pCount = 0;
426+
ze_init_driver_type_desc_t desc = {ZE_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC};
427+
desc.flags = UINT32_MAX;
428+
desc.pNext = nullptr;
429+
EXPECT_EQ(ZE_RESULT_SUCCESS, zeInitDrivers(&pCount, nullptr, &desc));
430+
bool enabled = false;
431+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetTracingLayerState(&enabled));
432+
}
433+
434+
TEST(
435+
TracingLayerState,
436+
GivenTracingLayerNotEnabledWhenCallingzelGetTracingLayerStateThenFalseIsReturned) {
437+
438+
uint32_t pCount = 0;
439+
ze_init_driver_type_desc_t desc = {ZE_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC};
440+
desc.flags = UINT32_MAX;
441+
desc.pNext = nullptr;
442+
EXPECT_EQ(ZE_RESULT_SUCCESS, zeInitDrivers(&pCount, nullptr, &desc));
443+
bool enabled = true;
444+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetTracingLayerState(&enabled));
445+
EXPECT_FALSE(enabled);
446+
}
447+
448+
TEST(
449+
TracingLayerState,
450+
GivenTracingLayerEnabledWhenCallingzelGetTracingLayerStateThenTrueIsReturned) {
451+
452+
uint32_t pCount = 0;
453+
ze_init_driver_type_desc_t desc = {ZE_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC};
454+
desc.flags = UINT32_MAX;
455+
desc.pNext = nullptr;
456+
EXPECT_EQ(ZE_RESULT_SUCCESS, zeInitDrivers(&pCount, nullptr, &desc));
457+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelEnableTracingLayer());
458+
bool enabled = false;
459+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetTracingLayerState(&enabled));
460+
EXPECT_TRUE(enabled);
461+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelDisableTracingLayer());
462+
}
463+
464+
TEST(
465+
TracingLayerState,
466+
GivenTracingLayerEnabledThenDisabledWhenCallingzelGetTracingLayerStateThenFalseIsReturned) {
467+
468+
uint32_t pCount = 0;
469+
ze_init_driver_type_desc_t desc = {ZE_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC};
470+
desc.flags = UINT32_MAX;
471+
desc.pNext = nullptr;
472+
EXPECT_EQ(ZE_RESULT_SUCCESS, zeInitDrivers(&pCount, nullptr, &desc));
473+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelEnableTracingLayer());
474+
bool enabled = false;
475+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetTracingLayerState(&enabled));
476+
EXPECT_TRUE(enabled);
477+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelDisableTracingLayer());
478+
enabled = true;
479+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetTracingLayerState(&enabled));
480+
EXPECT_FALSE(enabled);
481+
}
482+
483+
TEST(
484+
TracingLayerState,
485+
GivenMultipleEnableCallsWhenCallingzelGetTracingLayerStateThenTrueIsReturned) {
486+
487+
uint32_t pCount = 0;
488+
ze_init_driver_type_desc_t desc = {ZE_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC};
489+
desc.flags = UINT32_MAX;
490+
desc.pNext = nullptr;
491+
EXPECT_EQ(ZE_RESULT_SUCCESS, zeInitDrivers(&pCount, nullptr, &desc));
492+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelEnableTracingLayer());
493+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelEnableTracingLayer());
494+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelEnableTracingLayer());
495+
bool enabled = false;
496+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetTracingLayerState(&enabled));
497+
EXPECT_TRUE(enabled);
498+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelDisableTracingLayer());
499+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelDisableTracingLayer());
500+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelDisableTracingLayer());
501+
}
502+
503+
TEST(
504+
TracingLayerState,
505+
GivenMultipleEnableAndPartialDisableWhenCallingzelGetTracingLayerStateThenTrueIsReturned) {
506+
507+
uint32_t pCount = 0;
508+
ze_init_driver_type_desc_t desc = {ZE_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC};
509+
desc.flags = UINT32_MAX;
510+
desc.pNext = nullptr;
511+
EXPECT_EQ(ZE_RESULT_SUCCESS, zeInitDrivers(&pCount, nullptr, &desc));
512+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelEnableTracingLayer());
513+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelEnableTracingLayer());
514+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelEnableTracingLayer());
515+
bool enabled = false;
516+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetTracingLayerState(&enabled));
517+
EXPECT_TRUE(enabled);
518+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelDisableTracingLayer());
519+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetTracingLayerState(&enabled));
520+
EXPECT_TRUE(enabled);
521+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelDisableTracingLayer());
522+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetTracingLayerState(&enabled));
523+
EXPECT_TRUE(enabled);
524+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelDisableTracingLayer());
525+
enabled = true;
526+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetTracingLayerState(&enabled));
527+
EXPECT_FALSE(enabled);
528+
}
529+
530+
TEST(
531+
TracingLayerState,
532+
GivenMultipleCallsTozelGetTracingLayerStateWhenTracingEnabledThenAllReturnTrue) {
533+
534+
uint32_t pCount = 0;
535+
ze_init_driver_type_desc_t desc = {ZE_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC};
536+
desc.flags = UINT32_MAX;
537+
desc.pNext = nullptr;
538+
EXPECT_EQ(ZE_RESULT_SUCCESS, zeInitDrivers(&pCount, nullptr, &desc));
539+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelEnableTracingLayer());
540+
bool enabled1 = false, enabled2 = false, enabled3 = false;
541+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetTracingLayerState(&enabled1));
542+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetTracingLayerState(&enabled2));
543+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetTracingLayerState(&enabled3));
544+
EXPECT_TRUE(enabled1);
545+
EXPECT_TRUE(enabled2);
546+
EXPECT_TRUE(enabled3);
547+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelDisableTracingLayer());
548+
}
549+
550+
TEST(
551+
TracingLayerState,
552+
GivenMultipleCallsTozelGetTracingLayerStateWhenTracingDisabledThenAllReturnFalse) {
553+
554+
uint32_t pCount = 0;
555+
ze_init_driver_type_desc_t desc = {ZE_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC};
556+
desc.flags = UINT32_MAX;
557+
desc.pNext = nullptr;
558+
EXPECT_EQ(ZE_RESULT_SUCCESS, zeInitDrivers(&pCount, nullptr, &desc));
559+
bool enabled1 = true, enabled2 = true, enabled3 = true;
560+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetTracingLayerState(&enabled1));
561+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetTracingLayerState(&enabled2));
562+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetTracingLayerState(&enabled3));
563+
EXPECT_FALSE(enabled1);
564+
EXPECT_FALSE(enabled2);
565+
EXPECT_FALSE(enabled3);
566+
}
567+
568+
TEST(
569+
TracingLayerState,
570+
GivenTracingLayerEnabledViaEnvironmentWhenCallingzelGetTracingLayerStateThenTrueIsReturned) {
571+
572+
uint32_t pCount = 0;
573+
ze_init_driver_type_desc_t desc = {ZE_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC};
574+
desc.flags = UINT32_MAX;
575+
desc.pNext = nullptr;
576+
putenv_safe( const_cast<char *>( "ZE_ENABLE_TRACING_LAYER=1" ) );
577+
EXPECT_EQ(ZE_RESULT_SUCCESS, zeInitDrivers(&pCount, nullptr, &desc));
578+
bool enabled = false;
579+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetTracingLayerState(&enabled));
580+
EXPECT_TRUE(enabled);
581+
}
582+
583+
TEST(
584+
TracingLayerState,
585+
GivenTracingLayerEnabledViaEnvironmentWhenCallingzelEnableTracingLayerThenStateRemainsTrue) {
586+
587+
uint32_t pCount = 0;
588+
ze_init_driver_type_desc_t desc = {ZE_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC};
589+
desc.flags = UINT32_MAX;
590+
desc.pNext = nullptr;
591+
putenv_safe( const_cast<char *>( "ZE_ENABLE_TRACING_LAYER=1" ) );
592+
EXPECT_EQ(ZE_RESULT_SUCCESS, zeInitDrivers(&pCount, nullptr, &desc));
593+
bool enabled = false;
594+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetTracingLayerState(&enabled));
595+
EXPECT_TRUE(enabled);
596+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelEnableTracingLayer());
597+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetTracingLayerState(&enabled));
598+
EXPECT_TRUE(enabled);
599+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelDisableTracingLayer());
600+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetTracingLayerState(&enabled));
601+
EXPECT_TRUE(enabled);
602+
}
603+
604+
TEST(
605+
TracingLayerState,
606+
GivenTracingLayerEnabledViaEnvironmentAndDynamicallyWhenDisablingDynamicTracingThenStateRemainsTrue) {
607+
608+
uint32_t pCount = 0;
609+
ze_init_driver_type_desc_t desc = {ZE_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC};
610+
desc.flags = UINT32_MAX;
611+
desc.pNext = nullptr;
612+
putenv_safe( const_cast<char *>( "ZE_ENABLE_TRACING_LAYER=1" ) );
613+
EXPECT_EQ(ZE_RESULT_SUCCESS, zeInitDrivers(&pCount, nullptr, &desc));
614+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelEnableTracingLayer());
615+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelEnableTracingLayer());
616+
bool enabled = false;
617+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetTracingLayerState(&enabled));
618+
EXPECT_TRUE(enabled);
619+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelDisableTracingLayer());
620+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetTracingLayerState(&enabled));
621+
EXPECT_TRUE(enabled);
622+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelDisableTracingLayer());
623+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetTracingLayerState(&enabled));
624+
EXPECT_TRUE(enabled);
625+
}
626+
627+
628+
414629
class CaptureOutput {
415630
private:
416631
int original_fd;

0 commit comments

Comments
 (0)