intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-04 15:53:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

refactor: correct naming of enum class constants 11/n

Browse Source 
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski
2023-12-19 10:42:58 +00:00
committed by Compute-Runtime-Automation
parent 88534f1f3c
commit 138fb65401
62 changed files with 378 additions and 378 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
level_zero/core/source/event/event.cpp
View File

@@ -355,8 +355,8 @@ ze_result_t Event::destroy() {
}
void Event::enableCounterBasedMode(bool apiRequest) {
if (counterBasedMode == CounterBasedMode::InitiallyDisabled) {
counterBasedMode = apiRequest ? CounterBasedMode::ExplicitlyEnabled : CounterBasedMode::ImplicitlyEnabled;
if (counterBasedMode == CounterBasedMode::initiallyDisabled) {
counterBasedMode = apiRequest ? CounterBasedMode::explicitlyEnabled : CounterBasedMode::implicitlyEnabled;
}
}
@@ -365,8 +365,8 @@ void Event::disableImplicitCounterBasedMode() {
return;
}
if (counterBasedMode == CounterBasedMode::ImplicitlyEnabled || counterBasedMode == CounterBasedMode::InitiallyDisabled) {
counterBasedMode = CounterBasedMode::ImplicitlyDisabled;
if (counterBasedMode == CounterBasedMode::implicitlyEnabled || counterBasedMode == CounterBasedMode::initiallyDisabled) {
counterBasedMode = CounterBasedMode::implicitlyDisabled;
unsetInOrderExecInfo();
}
}

14
level_zero/core/source/event/event.h
View File

@@ -85,11 +85,11 @@ struct Event : _ze_event_handle_t {
enum class CounterBasedMode : uint32_t {
// For default flow (API)
InitiallyDisabled,
ExplicitlyEnabled,
initiallyDisabled,
explicitlyEnabled,
// For internal convertion (Immediate CL)
ImplicitlyEnabled,
ImplicitlyDisabled
implicitlyEnabled,
implicitlyDisabled
};
template <typename TagSizeT>
@@ -239,8 +239,8 @@ struct Event : _ze_event_handle_t {
this->metricNotification = metricNotification;
}
void updateInOrderExecState(std::shared_ptr<NEO::InOrderExecInfo> &newInOrderExecInfo, uint64_t signalValue, uint32_t allocationOffset);
bool isCounterBased() const { return ((counterBasedMode == CounterBasedMode::ExplicitlyEnabled) || (counterBasedMode == CounterBasedMode::ImplicitlyEnabled)); }
bool isCounterBasedExplicitlyEnabled() const { return (counterBasedMode == CounterBasedMode::ExplicitlyEnabled); }
bool isCounterBased() const { return ((counterBasedMode == CounterBasedMode::explicitlyEnabled) || (counterBasedMode == CounterBasedMode::implicitlyEnabled)); }
bool isCounterBasedExplicitlyEnabled() const { return (counterBasedMode == CounterBasedMode::explicitlyEnabled); }
void enableCounterBasedMode(bool apiRequest);
void disableImplicitCounterBasedMode();
NEO::GraphicsAllocation *getInOrderExecDataAllocation() const;
@@ -305,7 +305,7 @@ struct Event : _ze_event_handle_t {
uint32_t kernelCount = 1u;
uint32_t maxPacketCount = 0;
uint32_t totalEventSize = 0;
CounterBasedMode counterBasedMode = CounterBasedMode::InitiallyDisabled;
CounterBasedMode counterBasedMode = CounterBasedMode::initiallyDisabled;
ze_event_scope_flags_t signalScope = 0u;
ze_event_scope_flags_t waitScope = 0u;

2
level_zero/core/source/event/event_impl.inl
View File

@@ -540,7 +540,7 @@ ze_result_t EventImp<TagSizeT>::hostSynchronize(uint64_t timeout) {
template <typename TagSizeT>
ze_result_t EventImp<TagSizeT>::reset() {
if (this->counterBasedMode == CounterBasedMode::ExplicitlyEnabled) {
if (this->counterBasedMode == CounterBasedMode::explicitlyEnabled) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}

6
level_zero/core/source/image/image_hw.inl
View File

@@ -108,11 +108,11 @@ ze_result_t ImageCoreFamily<gfxCoreFamily>::initialize(Device *device, const ze_
auto gmmHelper = static_cast<const NEO::RootDeviceEnvironment &>(device->getNEODevice()->getRootDeviceEnvironment()).getGmmHelper();
if (gmm != nullptr) {
NEO::ImagePlane yuvPlaneType = NEO::ImagePlane::NO_PLANE;
NEO::ImagePlane yuvPlaneType = NEO::ImagePlane::noPlane;
if (isImageView() && (sourceImageFormatDesc->format.layout == ZE_IMAGE_FORMAT_LAYOUT_NV12)) {
yuvPlaneType = NEO::ImagePlane::PLANE_Y;
yuvPlaneType = NEO::ImagePlane::planeY;
if (imgInfo.plane == GMM_PLANE_U) {
yuvPlaneType = NEO::ImagePlane::PLANE_UV;
yuvPlaneType = NEO::ImagePlane::planeUV;
}
}
gmm->updateImgInfoAndDesc(imgInfo, 0u, yuvPlaneType);

6
level_zero/core/source/kernel/kernel_imp.h
View File

@@ -139,11 +139,11 @@ struct KernelImp : Kernel {
NEO::SlmPolicy getSlmPolicy() const override {
if (cacheConfigFlags & ZE_CACHE_CONFIG_FLAG_LARGE_SLM) {
return NEO::SlmPolicy::SlmPolicyLargeSlm;
return NEO::SlmPolicy::slmPolicyLargeSlm;
} else if (cacheConfigFlags & ZE_CACHE_CONFIG_FLAG_LARGE_DATA) {
return NEO::SlmPolicy::SlmPolicyLargeData;
return NEO::SlmPolicy::slmPolicyLargeData;
} else {
return NEO::SlmPolicy::SlmPolicyNone;
return NEO::SlmPolicy::slmPolicyNone;
}
}

6
level_zero/core/test/unit_tests/fixtures/in_order_cmd_list_fixture.h
View File

@@ -32,11 +32,11 @@ struct InOrderCmdListFixture : public ::Test<ModuleFixture> {
using EventImp<uint32_t>::signalScope;
void makeCounterBasedInitiallyDisabled() {
counterBasedMode = CounterBasedMode::InitiallyDisabled;
counterBasedMode = CounterBasedMode::initiallyDisabled;
}
void makeCounterBasedImplicitlyDisabled() {
counterBasedMode = CounterBasedMode::ImplicitlyDisabled;
counterBasedMode = CounterBasedMode::implicitlyDisabled;
}
};
@@ -76,7 +76,7 @@ struct InOrderCmdListFixture : public ::Test<ModuleFixture> {
for (uint32_t i = 0; i < numEvents; i++) {
eventDesc.index = i;
events.emplace_back(DestroyableZeUniquePtr<FixtureMockEvent>(static_cast<FixtureMockEvent *>(Event::create<typename GfxFamily::TimestampPacketType>(eventPool.get(), &eventDesc, device))));
EXPECT_EQ(Event::CounterBasedMode::ExplicitlyEnabled, events.back()->counterBasedMode);
EXPECT_EQ(Event::CounterBasedMode::explicitlyEnabled, events.back()->counterBasedMode);
EXPECT_TRUE(events.back()->isCounterBased());
}

56
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_launch_kernel_3.cpp
View File

@@ -836,10 +836,10 @@ HWTEST2_F(InOrderCmdListTests, givenIpcPoolEventWhenTryingToImplicitlyConverToCo
eventDesc.signal = ZE_EVENT_SCOPE_FLAG_HOST;
DestroyableZeUniquePtr<FixtureMockEvent> event0(static_cast<FixtureMockEvent *>(Event::create<typename FamilyType::TimestampPacketType>(eventPoolForExport.get(), &eventDesc, device)));
EXPECT_EQ(Event::CounterBasedMode::ImplicitlyDisabled, event0->counterBasedMode);
EXPECT_EQ(Event::CounterBasedMode::implicitlyDisabled, event0->counterBasedMode);
DestroyableZeUniquePtr<FixtureMockEvent> event1(static_cast<FixtureMockEvent *>(Event::create<typename FamilyType::TimestampPacketType>(eventPoolImported.get(), &eventDesc, device)));
EXPECT_EQ(Event::CounterBasedMode::ImplicitlyDisabled, event1->counterBasedMode);
EXPECT_EQ(Event::CounterBasedMode::implicitlyDisabled, event1->counterBasedMode);
}
HWTEST2_F(InOrderCmdListTests, givenNotSignaledInOrderWhenWhenCallingQueryStatusThenReturnNotReady, IsAtLeastSkl) {
@@ -1409,47 +1409,47 @@ HWTEST2_F(InOrderCmdListTests, givenImplicitEventConvertionEnabledWhenUsingImmed
events[2]->makeCounterBasedInitiallyDisabled();
immCmdList->appendLaunchKernel(kernel->toHandle(), groupCount, events[0]->toHandle(), 0, nullptr, launchParams, false);
EXPECT_EQ(Event::CounterBasedMode::InitiallyDisabled, events[0]->counterBasedMode);
EXPECT_EQ(Event::CounterBasedMode::initiallyDisabled, events[0]->counterBasedMode);
EXPECT_FALSE(events[0]->isCounterBased());
regularCmdList->appendLaunchKernel(kernel->toHandle(), groupCount, events[1]->toHandle(), 0, nullptr, launchParams, false);
EXPECT_EQ(Event::CounterBasedMode::InitiallyDisabled, events[1]->counterBasedMode);
EXPECT_EQ(Event::CounterBasedMode::initiallyDisabled, events[1]->counterBasedMode);
EXPECT_FALSE(events[1]->isCounterBased());
debugManager.flags.EnableImplicitConvertionToCounterBasedEvents.set(-1);
immCmdList->appendLaunchKernel(kernel->toHandle(), groupCount, events[0]->toHandle(), 0, nullptr, launchParams, false);
EXPECT_EQ(Event::CounterBasedMode::ImplicitlyEnabled, events[0]->counterBasedMode);
EXPECT_EQ(Event::CounterBasedMode::implicitlyEnabled, events[0]->counterBasedMode);
EXPECT_TRUE(events[0]->isCounterBased());
regularCmdList->appendLaunchKernel(kernel->toHandle(), groupCount, events[1]->toHandle(), 0, nullptr, launchParams, false);
EXPECT_EQ(Event::CounterBasedMode::ImplicitlyDisabled, events[1]->counterBasedMode);
EXPECT_EQ(Event::CounterBasedMode::implicitlyDisabled, events[1]->counterBasedMode);
EXPECT_FALSE(events[1]->isCounterBased());
outOfOrderImmCmdList->appendLaunchKernel(kernel->toHandle(), groupCount, events[2]->toHandle(), 0, nullptr, launchParams, false);
EXPECT_EQ(Event::CounterBasedMode::ImplicitlyDisabled, events[2]->counterBasedMode);
EXPECT_EQ(Event::CounterBasedMode::implicitlyDisabled, events[2]->counterBasedMode);
EXPECT_FALSE(events[2]->isCounterBased());
// Reuse on Regular = disable
regularCmdList->appendLaunchKernel(kernel->toHandle(), groupCount, events[0]->toHandle(), 0, nullptr, launchParams, false);
EXPECT_EQ(Event::CounterBasedMode::ImplicitlyDisabled, events[0]->counterBasedMode);
EXPECT_EQ(Event::CounterBasedMode::implicitlyDisabled, events[0]->counterBasedMode);
EXPECT_FALSE(events[0]->isCounterBased());
// Reuse on non-inOrder = disable
events[0]->counterBasedMode = Event::CounterBasedMode::ImplicitlyEnabled;
events[0]->counterBasedMode = Event::CounterBasedMode::implicitlyEnabled;
regularCmdList->appendLaunchKernel(kernel->toHandle(), groupCount, events[0]->toHandle(), 0, nullptr, launchParams, false);
EXPECT_EQ(Event::CounterBasedMode::ImplicitlyDisabled, events[0]->counterBasedMode);
EXPECT_EQ(Event::CounterBasedMode::implicitlyDisabled, events[0]->counterBasedMode);
EXPECT_FALSE(events[0]->isCounterBased());
// Reuse on already disabled
immCmdList->appendLaunchKernel(kernel->toHandle(), groupCount, events[0]->toHandle(), 0, nullptr, launchParams, false);
EXPECT_EQ(Event::CounterBasedMode::ImplicitlyDisabled, events[0]->counterBasedMode);
EXPECT_EQ(Event::CounterBasedMode::implicitlyDisabled, events[0]->counterBasedMode);
EXPECT_FALSE(events[0]->isCounterBased());
// On explicitly enabled
events[0]->counterBasedMode = Event::CounterBasedMode::ExplicitlyEnabled;
events[0]->counterBasedMode = Event::CounterBasedMode::explicitlyEnabled;
immCmdList->appendLaunchKernel(kernel->toHandle(), groupCount, events[0]->toHandle(), 0, nullptr, launchParams, false);
EXPECT_EQ(Event::CounterBasedMode::ExplicitlyEnabled, events[0]->counterBasedMode);
EXPECT_EQ(Event::CounterBasedMode::explicitlyEnabled, events[0]->counterBasedMode);
EXPECT_TRUE(events[0]->isCounterBased());
}
@@ -1461,7 +1461,7 @@ HWTEST2_F(InOrderCmdListTests, givenImplicitEventConvertionEnabledWhenUsingAppen
events[0]->enableCounterBasedMode(false);
immCmdList->appendEventReset(events[0]->toHandle());
EXPECT_EQ(Event::CounterBasedMode::ImplicitlyDisabled, events[0]->counterBasedMode);
EXPECT_EQ(Event::CounterBasedMode::implicitlyDisabled, events[0]->counterBasedMode);
}
HWTEST2_F(InOrderCmdListTests, givenImplicitEventConvertionEnabledWhenCallingAppendThenHandleInOrderExecInfo, IsAtLeastSkl) {
@@ -1593,55 +1593,55 @@ HWTEST2_F(InOrderCmdListTests, givenImmediateCmdListWhenDispatchingWithRegularEv
events[0]->makeCounterBasedInitiallyDisabled();
immCmdList->appendLaunchKernel(kernel->toHandle(), groupCount, eventHandle, 0, nullptr, launchParams, false);
EXPECT_EQ(Event::CounterBasedMode::ImplicitlyEnabled, events[0]->counterBasedMode);
EXPECT_EQ(Event::CounterBasedMode::implicitlyEnabled, events[0]->counterBasedMode);
events[0]->makeCounterBasedInitiallyDisabled();
immCmdList->appendLaunchCooperativeKernel(kernel->toHandle(), groupCount, eventHandle, 0, nullptr, false);
EXPECT_EQ(Event::CounterBasedMode::ImplicitlyEnabled, events[0]->counterBasedMode);
EXPECT_EQ(Event::CounterBasedMode::implicitlyEnabled, events[0]->counterBasedMode);
events[0]->makeCounterBasedInitiallyDisabled();
immCmdList->appendLaunchKernelIndirect(kernel->toHandle(), *static_cast<ze_group_count_t *>(alloc), eventHandle, 0, nullptr, false);
EXPECT_EQ(Event::CounterBasedMode::ImplicitlyEnabled, events[0]->counterBasedMode);
EXPECT_EQ(Event::CounterBasedMode::implicitlyEnabled, events[0]->counterBasedMode);
size_t rangeSizes = 1;
const void **ranges = reinterpret_cast<const void **>(&copyData[0]);
events[0]->makeCounterBasedInitiallyDisabled();
immCmdList->appendMemoryRangesBarrier(1, &rangeSizes, ranges, eventHandle, 0, nullptr);
EXPECT_EQ(Event::CounterBasedMode::ImplicitlyEnabled, events[0]->counterBasedMode);
EXPECT_EQ(Event::CounterBasedMode::implicitlyEnabled, events[0]->counterBasedMode);
events[0]->makeCounterBasedInitiallyDisabled();
copyOnlyCmdList->appendMemoryCopyBlitRegion(&allocationData, &allocationData, region, region, {0, 0, 0}, 0, 0, 0, 0, {0, 0, 0}, {0, 0, 0}, events[0].get(), 0, nullptr, false);
EXPECT_EQ(Event::CounterBasedMode::ImplicitlyEnabled, events[0]->counterBasedMode);
EXPECT_EQ(Event::CounterBasedMode::implicitlyEnabled, events[0]->counterBasedMode);
events[0]->makeCounterBasedInitiallyDisabled();
immCmdList->appendMemoryCopy(&copyData, &copyData, 1, eventHandle, 0, nullptr, false, false);
EXPECT_EQ(Event::CounterBasedMode::ImplicitlyEnabled, events[0]->counterBasedMode);
EXPECT_EQ(Event::CounterBasedMode::implicitlyEnabled, events[0]->counterBasedMode);
events[0]->makeCounterBasedInitiallyDisabled();
immCmdList->appendMemoryFill(alloc, &copyData, 1, 16, eventHandle, 0, nullptr, false);
EXPECT_EQ(Event::CounterBasedMode::ImplicitlyEnabled, events[0]->counterBasedMode);
EXPECT_EQ(Event::CounterBasedMode::implicitlyEnabled, events[0]->counterBasedMode);
events[0]->makeCounterBasedInitiallyDisabled();
copyOnlyCmdList->appendBlitFill(alloc, &copyData, 1, 16, events[0].get(), 0, nullptr, false);
EXPECT_EQ(Event::CounterBasedMode::ImplicitlyEnabled, events[0]->counterBasedMode);
EXPECT_EQ(Event::CounterBasedMode::implicitlyEnabled, events[0]->counterBasedMode);
events[0]->makeCounterBasedInitiallyDisabled();
immCmdList->appendSignalEvent(eventHandle);
EXPECT_EQ(Event::CounterBasedMode::ImplicitlyEnabled, events[0]->counterBasedMode);
EXPECT_EQ(Event::CounterBasedMode::implicitlyEnabled, events[0]->counterBasedMode);
events[0]->makeCounterBasedInitiallyDisabled();
immCmdList->appendWriteGlobalTimestamp(reinterpret_cast<uint64_t *>(copyData), eventHandle, 0, nullptr);
EXPECT_EQ(Event::CounterBasedMode::ImplicitlyEnabled, events[0]->counterBasedMode);
EXPECT_EQ(Event::CounterBasedMode::implicitlyEnabled, events[0]->counterBasedMode);
events[0]->makeCounterBasedInitiallyDisabled();
immCmdList->appendBarrier(eventHandle, 0, nullptr, false);
EXPECT_EQ(Event::CounterBasedMode::ImplicitlyEnabled, events[0]->counterBasedMode);
EXPECT_EQ(Event::CounterBasedMode::implicitlyEnabled, events[0]->counterBasedMode);
zex_wait_on_mem_desc_t desc;
desc.actionFlag = ZEX_WAIT_ON_MEMORY_FLAG_NOT_EQUAL;
events[0]->makeCounterBasedInitiallyDisabled();
immCmdList->appendWaitOnMemory(reinterpret_cast<void *>(&desc), copyData, 1, eventHandle, false);
EXPECT_EQ(Event::CounterBasedMode::ImplicitlyEnabled, events[0]->counterBasedMode);
EXPECT_EQ(Event::CounterBasedMode::implicitlyEnabled, events[0]->counterBasedMode);
auto hostAddress = static_cast<uint64_t *>(immCmdList->inOrderExecInfo->getDeviceCounterAllocation().getUnderlyingBuffer());
*hostAddress = immCmdList->inOrderExecInfo->getCounterValue();
@@ -1649,7 +1649,7 @@ HWTEST2_F(InOrderCmdListTests, givenImmediateCmdListWhenDispatchingWithRegularEv
immCmdList->copyThroughLockedPtrEnabled = true;
events[0]->makeCounterBasedInitiallyDisabled();
immCmdList->appendMemoryCopy(alloc, &copyData, 1, eventHandle, 0, nullptr, false, false);
EXPECT_EQ(Event::CounterBasedMode::ImplicitlyEnabled, events[0]->counterBasedMode);
EXPECT_EQ(Event::CounterBasedMode::implicitlyEnabled, events[0]->counterBasedMode);
context->freeMem(alloc);
}
@@ -5094,7 +5094,7 @@ HWTEST2_F(BcsSplitInOrderCmdListTests, givenImmediateCmdListWhenDispatchingWithR
events[0]->makeCounterBasedInitiallyDisabled();
immCmdList->appendMemoryCopy(&copyData, &copyData, copySize, eventHandle, 0, nullptr, false, false);
EXPECT_EQ(Event::CounterBasedMode::ImplicitlyEnabled, events[0]->counterBasedMode);
EXPECT_EQ(Event::CounterBasedMode::implicitlyEnabled, events[0]->counterBasedMode);
EXPECT_TRUE(verifySplit(1));
}

6
level_zero/core/test/unit_tests/sources/debugger/linux/test_l0_debugger_linux.cpp
View File

@@ -294,12 +294,12 @@ TEST_F(L0DebuggerLinuxTest, givenAllocationsWhenAttachingZebinModuleThenAllAlloc
kernelAllocs.push_back(&isaAllocation2);
drmMock->registeredDataSize = 0;
drmMock->registeredClass = NEO::DrmResourceClass::MaxSize;
drmMock->registeredClass = NEO::DrmResourceClass::maxSize;
EXPECT_TRUE(device->getL0Debugger()->attachZebinModuleToSegmentAllocations(kernelAllocs, handle, elfHandle));
EXPECT_EQ(sizeof(uint32_t), drmMock->registeredDataSize);
EXPECT_EQ(NEO::DrmResourceClass::L0ZebinModule, drmMock->registeredClass);
EXPECT_EQ(NEO::DrmResourceClass::l0ZebinModule, drmMock->registeredClass);
const auto containsModuleHandle = [handle](const auto &bufferObject) {
const auto &bindExtHandles = bufferObject.getBindExtHandles();
@@ -334,7 +334,7 @@ TEST_F(L0DebuggerLinuxTest, givenModuleAllocationsWhenAttachingZebinModuleThenBo
kernelAllocs.push_back(&isaAllocation2);
drmMock->registeredDataSize = 0;
drmMock->registeredClass = NEO::DrmResourceClass::MaxSize;
drmMock->registeredClass = NEO::DrmResourceClass::maxSize;
EXPECT_TRUE(device->getL0Debugger()->attachZebinModuleToSegmentAllocations(kernelAllocs, handle, elfHandle));

8
level_zero/core/test/unit_tests/sources/kernel/test_kernel.cpp
View File

@@ -1878,17 +1878,17 @@ TEST_F(KernelPropertiesTests, givenValidKernelAndNollocateStatelessPrivateSurfac
}
TEST_F(KernelPropertiesTests, givenValidKernelAndLargeSlmIsSetThenForceLargeSlmIsTrue) {
EXPECT_EQ(NEO::SlmPolicy::SlmPolicyNone, kernel->getSlmPolicy());
EXPECT_EQ(NEO::SlmPolicy::slmPolicyNone, kernel->getSlmPolicy());
ze_result_t res = kernel->setCacheConfig(ZE_CACHE_CONFIG_FLAG_LARGE_SLM);
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
EXPECT_EQ(NEO::SlmPolicy::SlmPolicyLargeSlm, kernel->getSlmPolicy());
EXPECT_EQ(NEO::SlmPolicy::slmPolicyLargeSlm, kernel->getSlmPolicy());
}
TEST_F(KernelPropertiesTests, givenValidKernelAndLargeDataIsSetThenForceLargeDataIsTrue) {
EXPECT_EQ(NEO::SlmPolicy::SlmPolicyNone, kernel->getSlmPolicy());
EXPECT_EQ(NEO::SlmPolicy::slmPolicyNone, kernel->getSlmPolicy());
ze_result_t res = kernel->setCacheConfig(ZE_CACHE_CONFIG_FLAG_LARGE_DATA);
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
EXPECT_EQ(NEO::SlmPolicy::SlmPolicyLargeData, kernel->getSlmPolicy());
EXPECT_EQ(NEO::SlmPolicy::slmPolicyLargeData, kernel->getSlmPolicy());
}
TEST_F(KernelPropertiesTests, WhenGetExtensionIsCalledWithUnknownExtensionTypeThenReturnNullptr) {