Skip to content

Commit fb5118b

Browse files
nrspruitnrspruit
authored
feature: Add zelGetTracingLayerState to query if tracing is enabled (#397)
Signed-off-by: Neil R. Spruit <neil.r.spruit@intel.com>
1 parent 86cb7fc commit fb5118b

5 files changed

Lines changed: 318 additions & 0 deletions

File tree

‎doc/loader_api.md‎

Lines changed: 13 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -70,4 +70,17 @@ This does not unload the tracing layer library such that one can call `zelEnable
7070

7171
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`.
7272

73+
### zelGetTracingLayerState
74+
75+
Queries the current enabled state of the tracing layer at runtime.
76+
77+
This function allows applications to check whether the tracing layer is currently active, returning the state through a boolean pointer.
78+
79+
- __*enabled__ Pointer to a boolean that will be set to `true` if the tracing layer is currently enabled, or `false` if it is disabled.
80+
81+
The function returns:
82+
- `ZE_RESULT_SUCCESS` on successful query
83+
- `ZE_RESULT_ERROR_INVALID_NULL_POINTER` if the `enabled` pointer is null
84+
85+
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.
7386

‎include/loader/ze_loader.h‎

Lines changed: 22 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -199,6 +199,28 @@ zelRegisterTeardownCallback(
199199
ZE_DLLEXPORT ze_result_t ZE_APICALL
200200
zelDisableTracingLayer();
201201

202+
/**
203+
* @brief Retrieves the current enabled state of the Level Zero tracing layer.
204+
*
205+
* This function queries whether the tracing layer is active and writes the result
206+
* to the provided boolean pointer.
207+
*
208+
* @param enabled
209+
* Pointer to a boolean that will be set to true if the tracing layer is
210+
* currently enabled, or false if it is disabled. Must be a valid, non-null
211+
* pointer.
212+
*
213+
* @return
214+
* ZE_RESULT_SUCCESS on success.
215+
* ZE_RESULT_ERROR_INVALID_NULL_POINTER if `enabled` is null.
216+
* Other ze_result_t error codes may be returned for implementation-specific failures.
217+
*
218+
* @note The tracing layer state is global to the process. The function is read-only
219+
* and thread-safe; multiple callers can query the state concurrently.
220+
*/
221+
ZE_DLLEXPORT ze_result_t ZE_APICALL
222+
zelGetTracingLayerState(bool* enabled); // Pointer to bool to receive tracing layer state
223+
202224
#if defined(__cplusplus)
203225
} // extern "C"
204226
#endif

‎source/lib/ze_lib.cpp‎

Lines changed: 30 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -635,6 +635,36 @@ zelEnableTracingLayer()
635635
return ZE_RESULT_SUCCESS;
636636
}
637637

638+
ze_result_t ZE_APICALL
639+
zelGetTracingLayerState
640+
(
641+
bool* enabled // Pointer to bool to receive tracing layer state
642+
)
643+
{
644+
if (enabled == nullptr) {
645+
return ZE_RESULT_ERROR_INVALID_NULL_POINTER;
646+
}
647+
#ifdef L0_STATIC_LOADER_BUILD
648+
if(nullptr == ze_lib::context->loader)
649+
return ZE_RESULT_ERROR_UNINITIALIZED;
650+
typedef ze_result_t (ZE_APICALL *zelGetTracingLayerStateInternal_t)(bool* enabled);
651+
auto getDynamicTracingState = reinterpret_cast<zelGetTracingLayerStateInternal_t>(
652+
GET_FUNCTION_PTR(ze_lib::context->loader, "zelGetTracingLayerState") );
653+
return getDynamicTracingState(enabled);
654+
#else
655+
if (ze_lib::context->dynamicTracingSupported == false) {
656+
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
657+
}
658+
if (loader::context) {
659+
*enabled = loader::context->tracingLayerEnabled;
660+
}
661+
if (!*enabled) {
662+
*enabled = (ze_lib::context->tracingLayerEnableCounter.load() > 0);
663+
}
664+
#endif
665+
return ZE_RESULT_SUCCESS;
666+
}
667+
638668
ze_result_t ZE_APICALL
639669
zelDisableTracingLayer()
640670
{

‎test/CMakeLists.txt‎

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

214+
add_test(NAME tests_tracing_layer_state_null_pointer COMMAND tests --gtest_filter=*TracingLayerState.GivenNullPointerWhenCallingzelGetTracingLayerStateThenErrorInvalidNullPointerIsReturned)
215+
set_property(TEST tests_tracing_layer_state_null_pointer PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_NULL_DRIVER=1")
216+
217+
add_test(NAME tests_tracing_layer_state_valid_pointer COMMAND tests --gtest_filter=*TracingLayerState.GivenValidPointerWhenCallingzelGetTracingLayerStateThenSuccessIsReturned)
218+
set_property(TEST tests_tracing_layer_state_valid_pointer PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_NULL_DRIVER=1")
219+
220+
add_test(NAME tests_tracing_layer_state_not_enabled COMMAND tests --gtest_filter=*TracingLayerState.GivenTracingLayerNotEnabledWhenCallingzelGetTracingLayerStateThenFalseIsReturned)
221+
set_property(TEST tests_tracing_layer_state_not_enabled PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_NULL_DRIVER=1")
222+
223+
add_test(NAME tests_tracing_layer_state_enabled COMMAND tests --gtest_filter=*TracingLayerState.GivenTracingLayerEnabledWhenCallingzelGetTracingLayerStateThenTrueIsReturned)
224+
set_property(TEST tests_tracing_layer_state_enabled PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_NULL_DRIVER=1")
225+
226+
add_test(NAME tests_tracing_layer_state_enabled_then_disabled COMMAND tests --gtest_filter=*TracingLayerState.GivenTracingLayerEnabledThenDisabledWhenCallingzelGetTracingLayerStateThenFalseIsReturned)
227+
set_property(TEST tests_tracing_layer_state_enabled_then_disabled PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_NULL_DRIVER=1")
228+
229+
add_test(NAME tests_tracing_layer_state_multiple_enable COMMAND tests --gtest_filter=*TracingLayerState.GivenMultipleEnableCallsWhenCallingzelGetTracingLayerStateThenTrueIsReturned)
230+
set_property(TEST tests_tracing_layer_state_multiple_enable PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_NULL_DRIVER=1")
231+
232+
add_test(NAME tests_tracing_layer_state_multiple_enable_partial_disable COMMAND tests --gtest_filter=*TracingLayerState.GivenMultipleEnableAndPartialDisableWhenCallingzelGetTracingLayerStateThenTrueIsReturned)
233+
set_property(TEST tests_tracing_layer_state_multiple_enable_partial_disable PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_NULL_DRIVER=1")
234+
235+
add_test(NAME tests_tracing_layer_state_multiple_calls_enabled COMMAND tests --gtest_filter=*TracingLayerState.GivenMultipleCallsTozelGetTracingLayerStateWhenTracingEnabledThenAllReturnTrue)
236+
set_property(TEST tests_tracing_layer_state_multiple_calls_enabled PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_NULL_DRIVER=1")
237+
238+
add_test(NAME tests_tracing_layer_state_multiple_calls_disabled COMMAND tests --gtest_filter=*TracingLayerState.GivenMultipleCallsTozelGetTracingLayerStateWhenTracingDisabledThenAllReturnFalse)
239+
set_property(TEST tests_tracing_layer_state_multiple_calls_disabled PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_NULL_DRIVER=1")
240+
241+
add_test(NAME tests_tracing_layer_state_enabled_via_environment COMMAND tests --gtest_filter=*TracingLayerState.GivenTracingLayerEnabledViaEnvironmentWhenCallingzelGetTracingLayerStateThenTrueIsReturned)
242+
set_property(TEST tests_tracing_layer_state_enabled_via_environment PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_NULL_DRIVER=1")
243+
244+
add_test(NAME tests_tracing_layer_state_enabled_via_environment_and_dynamic COMMAND tests --gtest_filter=*TracingLayerState.GivenTracingLayerEnabledViaEnvironmentWhenCallingzelEnableTracingLayerThenStateRemainsTrue)
245+
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")
246+
247+
add_test(NAME tests_tracing_layer_state_enabled_via_environment_disable_dynamic COMMAND tests --gtest_filter=*TracingLayerState.GivenTracingLayerEnabledViaEnvironmentAndDynamicallyWhenDisablingDynamicTracingThenStateRemainsTrue)
248+
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")
249+
214250
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)
215251
set_property(TEST test_zello_world_legacy PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1")
216252

@@ -670,6 +706,8 @@ else()
670706
set_property(TEST init_driver_unit_tests PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_NULL_DRIVER=1;")
671707
endif()
672708

709+
710+
673711
# 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.
674712
if(NOT MSVC)
675713
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
@@ -556,6 +556,221 @@ TEST(
556556
EXPECT_FALSE(zelCheckIsLoaderInTearDown());
557557
}
558558

559+
TEST(
560+
TracingLayerState,
561+
GivenNullPointerWhenCallingzelGetTracingLayerStateThenErrorInvalidNullPointerIsReturned) {
562+
563+
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_NULL_POINTER, zelGetTracingLayerState(nullptr));
564+
}
565+
566+
TEST(
567+
TracingLayerState,
568+
GivenValidPointerWhenCallingzelGetTracingLayerStateThenSuccessIsReturned) {
569+
570+
uint32_t pCount = 0;
571+
ze_init_driver_type_desc_t desc = {ZE_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC};
572+
desc.flags = UINT32_MAX;
573+
desc.pNext = nullptr;
574+
EXPECT_EQ(ZE_RESULT_SUCCESS, zeInitDrivers(&pCount, nullptr, &desc));
575+
bool enabled = false;
576+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetTracingLayerState(&enabled));
577+
}
578+
579+
TEST(
580+
TracingLayerState,
581+
GivenTracingLayerNotEnabledWhenCallingzelGetTracingLayerStateThenFalseIsReturned) {
582+
583+
uint32_t pCount = 0;
584+
ze_init_driver_type_desc_t desc = {ZE_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC};
585+
desc.flags = UINT32_MAX;
586+
desc.pNext = nullptr;
587+
EXPECT_EQ(ZE_RESULT_SUCCESS, zeInitDrivers(&pCount, nullptr, &desc));
588+
bool enabled = true;
589+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetTracingLayerState(&enabled));
590+
EXPECT_FALSE(enabled);
591+
}
592+
593+
TEST(
594+
TracingLayerState,
595+
GivenTracingLayerEnabledWhenCallingzelGetTracingLayerStateThenTrueIsReturned) {
596+
597+
uint32_t pCount = 0;
598+
ze_init_driver_type_desc_t desc = {ZE_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC};
599+
desc.flags = UINT32_MAX;
600+
desc.pNext = nullptr;
601+
EXPECT_EQ(ZE_RESULT_SUCCESS, zeInitDrivers(&pCount, nullptr, &desc));
602+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelEnableTracingLayer());
603+
bool enabled = false;
604+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetTracingLayerState(&enabled));
605+
EXPECT_TRUE(enabled);
606+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelDisableTracingLayer());
607+
}
608+
609+
TEST(
610+
TracingLayerState,
611+
GivenTracingLayerEnabledThenDisabledWhenCallingzelGetTracingLayerStateThenFalseIsReturned) {
612+
613+
uint32_t pCount = 0;
614+
ze_init_driver_type_desc_t desc = {ZE_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC};
615+
desc.flags = UINT32_MAX;
616+
desc.pNext = nullptr;
617+
EXPECT_EQ(ZE_RESULT_SUCCESS, zeInitDrivers(&pCount, nullptr, &desc));
618+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelEnableTracingLayer());
619+
bool enabled = false;
620+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetTracingLayerState(&enabled));
621+
EXPECT_TRUE(enabled);
622+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelDisableTracingLayer());
623+
enabled = true;
624+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetTracingLayerState(&enabled));
625+
EXPECT_FALSE(enabled);
626+
}
627+
628+
TEST(
629+
TracingLayerState,
630+
GivenMultipleEnableCallsWhenCallingzelGetTracingLayerStateThenTrueIsReturned) {
631+
632+
uint32_t pCount = 0;
633+
ze_init_driver_type_desc_t desc = {ZE_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC};
634+
desc.flags = UINT32_MAX;
635+
desc.pNext = nullptr;
636+
EXPECT_EQ(ZE_RESULT_SUCCESS, zeInitDrivers(&pCount, nullptr, &desc));
637+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelEnableTracingLayer());
638+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelEnableTracingLayer());
639+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelEnableTracingLayer());
640+
bool enabled = false;
641+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetTracingLayerState(&enabled));
642+
EXPECT_TRUE(enabled);
643+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelDisableTracingLayer());
644+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelDisableTracingLayer());
645+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelDisableTracingLayer());
646+
}
647+
648+
TEST(
649+
TracingLayerState,
650+
GivenMultipleEnableAndPartialDisableWhenCallingzelGetTracingLayerStateThenTrueIsReturned) {
651+
652+
uint32_t pCount = 0;
653+
ze_init_driver_type_desc_t desc = {ZE_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC};
654+
desc.flags = UINT32_MAX;
655+
desc.pNext = nullptr;
656+
EXPECT_EQ(ZE_RESULT_SUCCESS, zeInitDrivers(&pCount, nullptr, &desc));
657+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelEnableTracingLayer());
658+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelEnableTracingLayer());
659+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelEnableTracingLayer());
660+
bool enabled = false;
661+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetTracingLayerState(&enabled));
662+
EXPECT_TRUE(enabled);
663+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelDisableTracingLayer());
664+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetTracingLayerState(&enabled));
665+
EXPECT_TRUE(enabled);
666+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelDisableTracingLayer());
667+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetTracingLayerState(&enabled));
668+
EXPECT_TRUE(enabled);
669+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelDisableTracingLayer());
670+
enabled = true;
671+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetTracingLayerState(&enabled));
672+
EXPECT_FALSE(enabled);
673+
}
674+
675+
TEST(
676+
TracingLayerState,
677+
GivenMultipleCallsTozelGetTracingLayerStateWhenTracingEnabledThenAllReturnTrue) {
678+
679+
uint32_t pCount = 0;
680+
ze_init_driver_type_desc_t desc = {ZE_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC};
681+
desc.flags = UINT32_MAX;
682+
desc.pNext = nullptr;
683+
EXPECT_EQ(ZE_RESULT_SUCCESS, zeInitDrivers(&pCount, nullptr, &desc));
684+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelEnableTracingLayer());
685+
bool enabled1 = false, enabled2 = false, enabled3 = false;
686+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetTracingLayerState(&enabled1));
687+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetTracingLayerState(&enabled2));
688+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetTracingLayerState(&enabled3));
689+
EXPECT_TRUE(enabled1);
690+
EXPECT_TRUE(enabled2);
691+
EXPECT_TRUE(enabled3);
692+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelDisableTracingLayer());
693+
}
694+
695+
TEST(
696+
TracingLayerState,
697+
GivenMultipleCallsTozelGetTracingLayerStateWhenTracingDisabledThenAllReturnFalse) {
698+
699+
uint32_t pCount = 0;
700+
ze_init_driver_type_desc_t desc = {ZE_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC};
701+
desc.flags = UINT32_MAX;
702+
desc.pNext = nullptr;
703+
EXPECT_EQ(ZE_RESULT_SUCCESS, zeInitDrivers(&pCount, nullptr, &desc));
704+
bool enabled1 = true, enabled2 = true, enabled3 = true;
705+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetTracingLayerState(&enabled1));
706+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetTracingLayerState(&enabled2));
707+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetTracingLayerState(&enabled3));
708+
EXPECT_FALSE(enabled1);
709+
EXPECT_FALSE(enabled2);
710+
EXPECT_FALSE(enabled3);
711+
}
712+
713+
TEST(
714+
TracingLayerState,
715+
GivenTracingLayerEnabledViaEnvironmentWhenCallingzelGetTracingLayerStateThenTrueIsReturned) {
716+
717+
uint32_t pCount = 0;
718+
ze_init_driver_type_desc_t desc = {ZE_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC};
719+
desc.flags = UINT32_MAX;
720+
desc.pNext = nullptr;
721+
putenv_safe( const_cast<char *>( "ZE_ENABLE_TRACING_LAYER=1" ) );
722+
EXPECT_EQ(ZE_RESULT_SUCCESS, zeInitDrivers(&pCount, nullptr, &desc));
723+
bool enabled = false;
724+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetTracingLayerState(&enabled));
725+
EXPECT_TRUE(enabled);
726+
}
727+
728+
TEST(
729+
TracingLayerState,
730+
GivenTracingLayerEnabledViaEnvironmentWhenCallingzelEnableTracingLayerThenStateRemainsTrue) {
731+
732+
uint32_t pCount = 0;
733+
ze_init_driver_type_desc_t desc = {ZE_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC};
734+
desc.flags = UINT32_MAX;
735+
desc.pNext = nullptr;
736+
putenv_safe( const_cast<char *>( "ZE_ENABLE_TRACING_LAYER=1" ) );
737+
EXPECT_EQ(ZE_RESULT_SUCCESS, zeInitDrivers(&pCount, nullptr, &desc));
738+
bool enabled = false;
739+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetTracingLayerState(&enabled));
740+
EXPECT_TRUE(enabled);
741+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelEnableTracingLayer());
742+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetTracingLayerState(&enabled));
743+
EXPECT_TRUE(enabled);
744+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelDisableTracingLayer());
745+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetTracingLayerState(&enabled));
746+
EXPECT_TRUE(enabled);
747+
}
748+
749+
TEST(
750+
TracingLayerState,
751+
GivenTracingLayerEnabledViaEnvironmentAndDynamicallyWhenDisablingDynamicTracingThenStateRemainsTrue) {
752+
753+
uint32_t pCount = 0;
754+
ze_init_driver_type_desc_t desc = {ZE_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC};
755+
desc.flags = UINT32_MAX;
756+
desc.pNext = nullptr;
757+
putenv_safe( const_cast<char *>( "ZE_ENABLE_TRACING_LAYER=1" ) );
758+
EXPECT_EQ(ZE_RESULT_SUCCESS, zeInitDrivers(&pCount, nullptr, &desc));
759+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelEnableTracingLayer());
760+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelEnableTracingLayer());
761+
bool enabled = false;
762+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetTracingLayerState(&enabled));
763+
EXPECT_TRUE(enabled);
764+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelDisableTracingLayer());
765+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetTracingLayerState(&enabled));
766+
EXPECT_TRUE(enabled);
767+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelDisableTracingLayer());
768+
EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetTracingLayerState(&enabled));
769+
EXPECT_TRUE(enabled);
770+
}
771+
772+
773+
559774
class CaptureOutput {
560775
private:
561776
int original_fd;

0 commit comments

Comments
 (0)