From 2d21d42edbf6d2b7e9083f11a572090b93489368 Mon Sep 17 00:00:00 2001 From: Lukasz Jobczyk Date: Mon, 9 Jan 2023 14:09:11 +0000 Subject: [PATCH] Adjust bcs split to flush task submission Signed-off-by: Lukasz Jobczyk --- .../source/cmdlist/cmdlist_hw_immediate.h | 5 +- .../source/cmdlist/cmdlist_hw_immediate.inl | 30 +++++---- level_zero/core/source/device/bcs_split.h | 12 +++- .../sources/cmdlist/test_cmdlist_1.cpp | 14 +++- .../xe_hpc_core/test_cmdqueue_xe_hpc_core.cpp | 66 ++++++++++++++++++- 5 files changed, 109 insertions(+), 18 deletions(-) diff --git a/level_zero/core/source/cmdlist/cmdlist_hw_immediate.h b/level_zero/core/source/cmdlist/cmdlist_hw_immediate.h index 43f83ad150..510b835943 100644 --- a/level_zero/core/source/cmdlist/cmdlist_hw_immediate.h +++ b/level_zero/core/source/cmdlist/cmdlist_hw_immediate.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2020-2022 Intel Corporation + * Copyright (C) 2020-2023 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -128,9 +128,10 @@ struct CommandListCoreFamilyImmediate : public CommandListCoreFamily::updateDispatchFlagsWithRequi } template -NEO::CompletionStamp CommandListCoreFamilyImmediate::flushBcsTask(NEO::LinearStream &cmdStreamTask, size_t taskStartOffset, bool hasStallingCmds, bool hasRelaxedOrderingDependencies) { +NEO::CompletionStamp CommandListCoreFamilyImmediate::flushBcsTask(NEO::LinearStream &cmdStreamTask, size_t taskStartOffset, bool hasStallingCmds, bool hasRelaxedOrderingDependencies, NEO::CommandStreamReceiver *csr) { NEO::DispatchBcsFlags dispatchBcsFlags( this->isSyncModeQueue, // flushTaskCount hasStallingCmds, // hasStallingCmds hasRelaxedOrderingDependencies // hasRelaxedOrderingDependencies ); - return this->csr->flushBcsTask(cmdStreamTask, taskStartOffset, dispatchBcsFlags, this->device->getHwInfo()); + return csr->flushBcsTask(cmdStreamTask, taskStartOffset, dispatchBcsFlags, this->device->getHwInfo()); } template @@ -180,16 +180,22 @@ NEO::CompletionStamp CommandListCoreFamilyImmediate::flushRegular template ze_result_t CommandListCoreFamilyImmediate::executeCommandListImmediateWithFlushTask(bool performMigration, bool hasStallingCmds, bool hasRelaxedOrderingDependencies) { + return executeCommandListImmediateWithFlushTaskImpl(performMigration, hasStallingCmds, hasRelaxedOrderingDependencies, this->cmdQImmediate); +} + +template +inline ze_result_t CommandListCoreFamilyImmediate::executeCommandListImmediateWithFlushTaskImpl(bool performMigration, bool hasStallingCmds, bool hasRelaxedOrderingDependencies, CommandQueue *cmdQ) { this->commandContainer.removeDuplicatesFromResidencyContainer(); auto commandStream = this->commandContainer.getCommandStream(); size_t commandStreamStart = this->cmdListCurrentStartOffset; - auto lockCSR = this->csr->obtainUniqueOwnership(); + auto csr = static_cast(cmdQ)->getCsr(); + auto lockCSR = csr->obtainUniqueOwnership(); std::unique_lock lockForIndirect; if (this->hasIndirectAllocationsAllowed()) { - this->cmdQImmediate->handleIndirectAllocationResidency(this->getUnifiedMemoryControls(), lockForIndirect, performMigration); + cmdQ->handleIndirectAllocationResidency(this->getUnifiedMemoryControls(), lockForIndirect, performMigration); } if (performMigration) { @@ -200,7 +206,7 @@ ze_result_t CommandListCoreFamilyImmediate::executeCommandListImm } } - this->cmdQImmediate->makeResidentAndMigrate(performMigration, this->commandContainer.getResidencyContainer()); + cmdQ->makeResidentAndMigrate(performMigration, this->commandContainer.getResidencyContainer()); static_cast *>(this->cmdQImmediate)->patchCommands(*this, 0u); @@ -213,12 +219,12 @@ ze_result_t CommandListCoreFamilyImmediate::executeCommandListImm prefetchManager->migrateAllocationsToGpu(this->getPrefetchContext(), *this->device->getDriverHandle()->getSvmAllocsManager(), *this->device->getNEODevice(), - *this->csr); + *csr); } NEO::CompletionStamp completionStamp; if (isCopyOnly()) { - completionStamp = flushBcsTask(*commandStream, commandStreamStart, hasStallingCmds, hasRelaxedOrderingDependencies); + completionStamp = flushBcsTask(*commandStream, commandStreamStart, hasStallingCmds, hasRelaxedOrderingDependencies, csr); } else { completionStamp = flushRegularTask(*commandStream, commandStreamStart, hasStallingCmds, hasRelaxedOrderingDependencies); } @@ -232,11 +238,11 @@ ze_result_t CommandListCoreFamilyImmediate::executeCommandListImm if (this->isSyncModeQueue) { auto timeoutMicroseconds = NEO::TimeoutControls::maxTimeout; - const auto waitStatus = this->csr->waitForCompletionWithTimeout(NEO::WaitParams{false, false, timeoutMicroseconds}, completionStamp.taskCount); + const auto waitStatus = csr->waitForCompletionWithTimeout(NEO::WaitParams{false, false, timeoutMicroseconds}, completionStamp.taskCount); if (waitStatus == NEO::WaitStatus::GpuHang) { return ZE_RESULT_ERROR_DEVICE_LOST; } - this->csr->getInternalAllocationStorage()->cleanAllocationList(completionStamp.taskCount, NEO::AllocationUsage::TEMPORARY_ALLOCATION); + csr->getInternalAllocationStorage()->cleanAllocationList(completionStamp.taskCount, NEO::AllocationUsage::TEMPORARY_ALLOCATION); } this->cmdListCurrentStartOffset = commandStream->getUsed(); @@ -356,7 +362,7 @@ ze_result_t CommandListCoreFamilyImmediate::appendMemoryCopy( } if (this->isAppendSplitNeeded(dstptr, srcptr, size)) { - ret = static_cast(this->device)->bcsSplit.appendSplitCall(this, dstptr, srcptr, size, hSignalEvent, [&](void *dstptrParam, const void *srcptrParam, size_t sizeParam, ze_event_handle_t hSignalEventParam) { + ret = static_cast(this->device)->bcsSplit.appendSplitCall(this, dstptr, srcptr, size, hSignalEvent, true, (numWaitEvents > 0), [&](void *dstptrParam, const void *srcptrParam, size_t sizeParam, ze_event_handle_t hSignalEventParam) { return CommandListCoreFamily::appendMemoryCopy(dstptrParam, srcptrParam, sizeParam, hSignalEventParam, numWaitEvents, phWaitEvents); }); } else { @@ -388,7 +394,7 @@ ze_result_t CommandListCoreFamilyImmediate::appendMemoryCopyRegio ze_result_t ret; if (this->isAppendSplitNeeded(dstPtr, srcPtr, this->getTotalSizeForCopyRegion(dstRegion, dstPitch, dstSlicePitch))) { - ret = static_cast(this->device)->bcsSplit.appendSplitCall(this, dstRegion->originX, srcRegion->originX, dstRegion->width, hSignalEvent, [&](uint32_t dstOriginXParam, uint32_t srcOriginXParam, size_t sizeParam, ze_event_handle_t hSignalEventParam) { + ret = static_cast(this->device)->bcsSplit.appendSplitCall(this, dstRegion->originX, srcRegion->originX, dstRegion->width, hSignalEvent, true, (numWaitEvents > 0), [&](uint32_t dstOriginXParam, uint32_t srcOriginXParam, size_t sizeParam, ze_event_handle_t hSignalEventParam) { ze_copy_region_t dstRegionLocal = {}; ze_copy_region_t srcRegionLocal = {}; memcpy(&dstRegionLocal, dstRegion, sizeof(ze_copy_region_t)); @@ -464,7 +470,7 @@ ze_result_t CommandListCoreFamilyImmediate::appendPageFaultCopy(N if (this->isAppendSplitNeeded(dstAllocation->getMemoryPool(), srcAllocation->getMemoryPool(), size)) { uintptr_t dstAddress = static_cast(dstAllocation->getGpuAddress()); uintptr_t srcAddress = static_cast(srcAllocation->getGpuAddress()); - ret = static_cast(this->device)->bcsSplit.appendSplitCall(this, dstAddress, srcAddress, size, nullptr, [&](uintptr_t dstAddressParam, uintptr_t srcAddressParam, size_t sizeParam, ze_event_handle_t hSignalEventParam) { + ret = static_cast(this->device)->bcsSplit.appendSplitCall(this, dstAddress, srcAddress, size, nullptr, false, false, [&](uintptr_t dstAddressParam, uintptr_t srcAddressParam, size_t sizeParam, ze_event_handle_t hSignalEventParam) { this->appendMemoryCopyBlit(dstAddressParam, dstAllocation, 0u, srcAddressParam, srcAllocation, 0u, sizeParam); diff --git a/level_zero/core/source/device/bcs_split.h b/level_zero/core/source/device/bcs_split.h index 56c5f1885a..498b9c1113 100644 --- a/level_zero/core/source/device/bcs_split.h +++ b/level_zero/core/source/device/bcs_split.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2022 Intel Corporation + * Copyright (C) 2022-2023 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -58,6 +58,8 @@ struct BcsSplit { K srcptr, size_t size, ze_event_handle_t hSignalEvent, + bool performMigration, + bool hasRelaxedOrderingDependencies, std::function appendCall) { ze_result_t result = ZE_RESULT_SUCCESS; @@ -78,7 +80,13 @@ struct BcsSplit { auto eventHandle = this->events.subcopy[subcopyEventIndex + i]->toHandle(); result = appendCall(localDstPtr, localSrcPtr, localSize, eventHandle); - cmdList->executeCommandListImmediateImpl(true, this->cmdQs[i]); + + if (cmdList->isFlushTaskSubmissionEnabled) { + cmdList->executeCommandListImmediateWithFlushTaskImpl(performMigration, false, hasRelaxedOrderingDependencies, this->cmdQs[i]); + } else { + cmdList->executeCommandListImmediateImpl(performMigration, this->cmdQs[i]); + } + eventHandles.push_back(eventHandle); totalSize -= localSize; diff --git a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_1.cpp b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_1.cpp index 03a2cd482e..89a18eb41c 100644 --- a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_1.cpp +++ b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_1.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2020-2022 Intel Corporation + * Copyright (C) 2020-2023 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -1203,11 +1203,13 @@ TEST_F(CommandListCreate, GivenGpuHangWhenCreatingImmCmdListWithSyncModeAndAppen const auto oldCsr = commandList->csr; commandList->csr = &mockCommandStreamReceiver; + static_cast *>(commandList->cmdQImmediate)->csr = &mockCommandStreamReceiver; const auto appendBarrierResult = commandList->appendBarrier(nullptr, 0, nullptr); EXPECT_EQ(ZE_RESULT_ERROR_DEVICE_LOST, appendBarrierResult); commandList->csr = oldCsr; + static_cast *>(commandList->cmdQImmediate)->csr = oldCsr; } HWTEST_F(CommandListCreate, GivenGpuHangWhenCreatingImmediateCommandListAndAppendingSignalEventsThenDeviceLostIsReturned) { @@ -1259,11 +1261,13 @@ HWTEST_F(CommandListCreate, GivenGpuHangWhenCreatingImmediateCommandListAndAppen const auto oldCsr = commandList->csr; commandList->csr = &mockCommandStreamReceiver; + static_cast *>(commandList->cmdQImmediate)->csr = &mockCommandStreamReceiver; returnValue = commandList->appendSignalEvent(event); EXPECT_EQ(ZE_RESULT_ERROR_DEVICE_LOST, returnValue); commandList->csr = oldCsr; + static_cast *>(commandList->cmdQImmediate)->csr = oldCsr; } HWTEST2_F(CommandListCreate, GivenGpuHangOnExecutingCommandListsWhenCreatingImmediateCommandListAndWaitingOnEventsThenDeviceLostIsReturned, IsSKL) { @@ -1306,11 +1310,13 @@ HWTEST2_F(CommandListCreate, GivenGpuHangOnExecutingCommandListsWhenCreatingImme const auto oldCsr = commandList->csr; commandList->csr = &mockCommandStreamReceiver; + static_cast *>(commandList->cmdQImmediate)->csr = &mockCommandStreamReceiver; returnValue = commandList->appendWaitOnEvents(1, &event, false); EXPECT_EQ(ZE_RESULT_ERROR_DEVICE_LOST, returnValue); commandList->csr = oldCsr; + static_cast *>(commandList->cmdQImmediate)->csr = oldCsr; } TEST_F(CommandListCreate, givenImmediateCommandListWhenThereIsNoEnoughSpaceForImmediateCommandThenNextCommandBufferIsUsed) { @@ -1380,10 +1386,12 @@ HWTEST2_F(CommandListCreate, GivenGpuHangOnSynchronizingWhenCreatingImmediateCom mockCommandStreamReceiver.waitForCompletionWithTimeoutReturnValue = WaitStatus::GpuHang; const auto oldCsr = commandList->csr; commandList->csr = &mockCommandStreamReceiver; + static_cast *>(commandList->cmdQImmediate)->csr = &mockCommandStreamReceiver; returnValue = commandList->appendWaitOnEvents(1, &event, false); EXPECT_EQ(ZE_RESULT_ERROR_DEVICE_LOST, returnValue); commandList->csr = oldCsr; + static_cast *>(commandList->cmdQImmediate)->csr = oldCsr; } HWTEST2_F(CommandListCreate, GivenGpuHangOnSynchronizingWhenCreatingImmediateCommandListWithoutFlushTaskAndWaitingOnEventsThenDeviceLostIsReturnedFromExecute, IsSKL) { @@ -1540,11 +1548,13 @@ HWTEST_F(CommandListCreate, GivenGpuHangWhenCreatingImmediateCommandListAndAppen const auto oldCsr = commandList->csr; commandList->csr = &mockCommandStreamReceiver; + static_cast *>(commandList->cmdQImmediate)->csr = &mockCommandStreamReceiver; returnValue = commandList->appendEventReset(event); EXPECT_EQ(ZE_RESULT_ERROR_DEVICE_LOST, returnValue); commandList->csr = oldCsr; + static_cast *>(commandList->cmdQImmediate)->csr = oldCsr; } HWTEST_F(CommandListCreate, GivenImmediateCommandListWithFlushTaskCreatedThenNumIddPerBlockIsOne) { @@ -1611,11 +1621,13 @@ HWTEST_F(CommandListCreate, GivenGpuHangAndEnabledFlushTaskSubmissionFlagWhenCre const auto oldCsr = commandList->csr; commandList->csr = &mockCommandStreamReceiver; + static_cast *>(commandList->cmdQImmediate)->csr = &mockCommandStreamReceiver; returnValue = commandList->appendWaitOnEvents(1, &event, false); EXPECT_EQ(ZE_RESULT_ERROR_DEVICE_LOST, returnValue); commandList->csr = oldCsr; + static_cast *>(commandList->cmdQImmediate)->csr = oldCsr; } TEST_F(CommandListCreate, whenCreatingImmCmdListWithSyncModeAndAppendResetEventThenUpdateTaskCountNeededFlagIsDisabled) { diff --git a/level_zero/core/test/unit_tests/xe_hpc_core/test_cmdqueue_xe_hpc_core.cpp b/level_zero/core/test/unit_tests/xe_hpc_core/test_cmdqueue_xe_hpc_core.cpp index 4e675548be..af50d8f02e 100644 --- a/level_zero/core/test/unit_tests/xe_hpc_core/test_cmdqueue_xe_hpc_core.cpp +++ b/level_zero/core/test/unit_tests/xe_hpc_core/test_cmdqueue_xe_hpc_core.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2021-2022 Intel Corporation + * Copyright (C) 2021-2023 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -283,6 +283,7 @@ HWTEST2_F(CommandQueueCommandsXeHpc, givenSplitBcsCopyAndImmediateCommandListWhe DebugManagerStateRestore restorer; DebugManager.flags.SplitBcsCopy.set(1); + DebugManager.flags.EnableFlushTaskSubmission.set(0); ze_result_t returnValue; auto hwInfo = *NEO::defaultHwInfo; @@ -334,6 +335,7 @@ HWTEST2_F(CommandQueueCommandsXeHpc, givenSplitBcsCopyAndImmediateCommandListWhe DebugManagerStateRestore restorer; DebugManager.flags.SplitBcsCopy.set(1); + DebugManager.flags.EnableFlushTaskSubmission.set(0); ze_result_t returnValue; auto hwInfo = *NEO::defaultHwInfo; @@ -383,6 +385,7 @@ HWTEST2_F(CommandQueueCommandsXeHpc, givenSplitBcsCopyAndImmediateCommandListWhe DebugManagerStateRestore restorer; DebugManager.flags.SplitBcsCopy.set(1); + DebugManager.flags.EnableFlushTaskSubmission.set(0); ze_result_t returnValue; auto hwInfo = *NEO::defaultHwInfo; @@ -430,11 +433,67 @@ HWTEST2_F(CommandQueueCommandsXeHpc, givenSplitBcsCopyAndImmediateCommandListWhe context->freeMem(dstPtr); } +HWTEST2_F(CommandQueueCommandsXeHpc, givenFlushTaskSubmissionEnabledAndSplitBcsCopyAndImmediateCommandListWhenAppendingMemoryCopyThenSuccessIsReturned, IsXeHpcCore) { + using MI_FLUSH_DW = typename FamilyType::MI_FLUSH_DW; + + DebugManagerStateRestore restorer; + DebugManager.flags.SplitBcsCopy.set(1); + + ze_result_t returnValue; + auto hwInfo = *NEO::defaultHwInfo; + hwInfo.featureTable.ftrBcsInfo = 0b111111111; + hwInfo.capabilityTable.blitterOperationsSupported = true; + auto testNeoDevice = NEO::MockDevice::createWithNewExecutionEnvironment(&hwInfo); + auto testL0Device = std::unique_ptr(L0::Device::create(driverHandle.get(), testNeoDevice, false, &returnValue)); + + ze_command_queue_desc_t desc = {}; + desc.ordinal = static_cast(testNeoDevice->getEngineGroupIndexFromEngineGroupType(NEO::EngineGroupType::Copy)); + + std::unique_ptr commandList0(CommandList::createImmediate(productFamily, + testL0Device.get(), + &desc, + false, + NEO::EngineGroupType::Copy, + returnValue)); + ASSERT_NE(nullptr, commandList0); + EXPECT_EQ(static_cast(testL0Device.get())->bcsSplit.cmdQs.size(), 4u); + EXPECT_EQ(static_cast(static_cast(testL0Device.get())->bcsSplit.cmdQs[0])->getTaskCount(), 0u); + EXPECT_EQ(static_cast(static_cast(testL0Device.get())->bcsSplit.cmdQs[1])->getTaskCount(), 0u); + EXPECT_EQ(static_cast(static_cast(testL0Device.get())->bcsSplit.cmdQs[2])->getTaskCount(), 0u); + EXPECT_EQ(static_cast(static_cast(testL0Device.get())->bcsSplit.cmdQs[3])->getTaskCount(), 0u); + + constexpr size_t alignment = 4096u; + constexpr size_t size = 8 * MemoryConstants::megaByte; + void *srcPtr; + void *dstPtr; + ze_device_mem_alloc_desc_t deviceDesc = {}; + context->allocDeviceMem(device->toHandle(), + &deviceDesc, + size, alignment, &srcPtr); + ze_host_mem_alloc_desc_t hostDesc = {}; + context->allocHostMem(&hostDesc, size, alignment, &dstPtr); + + auto result = commandList0->appendMemoryCopy(dstPtr, srcPtr, size, nullptr, 0, nullptr); + ASSERT_EQ(ZE_RESULT_SUCCESS, result); + EXPECT_EQ(static_cast(static_cast(testL0Device.get())->bcsSplit.cmdQs[0])->getTaskCount(), 0u); + EXPECT_EQ(static_cast(static_cast(testL0Device.get())->bcsSplit.cmdQs[1])->getTaskCount(), 0u); + EXPECT_EQ(static_cast(static_cast(testL0Device.get())->bcsSplit.cmdQs[2])->getTaskCount(), 0u); + EXPECT_EQ(static_cast(static_cast(testL0Device.get())->bcsSplit.cmdQs[3])->getTaskCount(), 0u); + EXPECT_EQ(static_cast(static_cast(testL0Device.get())->bcsSplit.cmdQs[0])->getCsr()->peekTaskCount(), 1u); + EXPECT_EQ(static_cast(static_cast(testL0Device.get())->bcsSplit.cmdQs[1])->getCsr()->peekTaskCount(), 1u); + EXPECT_EQ(static_cast(static_cast(testL0Device.get())->bcsSplit.cmdQs[2])->getCsr()->peekTaskCount(), 1u); + EXPECT_EQ(static_cast(static_cast(testL0Device.get())->bcsSplit.cmdQs[3])->getCsr()->peekTaskCount(), 1u); + + context->freeMem(srcPtr); + context->freeMem(dstPtr); +} + HWTEST2_F(CommandQueueCommandsXeHpc, givenSplitBcsCopyAndImmediateCommandListWhenAppendingMemoryCopyThenSuccessIsReturned, IsXeHpcCore) { using MI_FLUSH_DW = typename FamilyType::MI_FLUSH_DW; DebugManagerStateRestore restorer; DebugManager.flags.SplitBcsCopy.set(1); + DebugManager.flags.EnableFlushTaskSubmission.set(0); ze_result_t returnValue; auto hwInfo = *NEO::defaultHwInfo; @@ -484,6 +543,7 @@ HWTEST2_F(CommandQueueCommandsXeHpc, givenSplitBcsCopyAndImmediateCommandListWhe HWTEST2_F(CommandQueueCommandsXeHpc, givenSplitBcsCopyAndImmediateCommandListWhenAppendingMemoryCopyRegionThenSuccessIsReturned, IsXeHpcCore) { DebugManagerStateRestore restorer; DebugManager.flags.SplitBcsCopy.set(1); + DebugManager.flags.EnableFlushTaskSubmission.set(0); ze_result_t returnValue; auto hwInfo = *NEO::defaultHwInfo; @@ -536,6 +596,7 @@ HWTEST2_F(CommandQueueCommandsXeHpc, givenSplitBcsCopyAndImmediateCommandListWhe DebugManagerStateRestore restorer; DebugManager.flags.SplitBcsCopy.set(1); + DebugManager.flags.EnableFlushTaskSubmission.set(0); ze_result_t returnValue; auto hwInfo = *NEO::defaultHwInfo; @@ -605,6 +666,7 @@ HWTEST2_F(CommandQueueCommandsXeHpc, givenSplitBcsCopyAndImmediateCommandListWhe DebugManagerStateRestore restorer; DebugManager.flags.SplitBcsCopy.set(1); + DebugManager.flags.EnableFlushTaskSubmission.set(0); ze_result_t returnValue; auto hwInfo = *NEO::defaultHwInfo; @@ -661,6 +723,7 @@ HWTEST2_F(CommandQueueCommandsXeHpc, givenSplitBcsCopyAndImmediateCommandListWhe DebugManagerStateRestore restorer; DebugManager.flags.SplitBcsCopy.set(1); + DebugManager.flags.EnableFlushTaskSubmission.set(0); ze_result_t returnValue; auto hwInfo = *NEO::defaultHwInfo; @@ -721,6 +784,7 @@ HWTEST2_F(CommandQueueCommandsXeHpc, givenSplitBcsCopyAndImmediateCommandListWhe DebugManagerStateRestore restorer; DebugManager.flags.SplitBcsCopy.set(1); + DebugManager.flags.EnableFlushTaskSubmission.set(0); ze_result_t returnValue; auto hwInfo = *NEO::defaultHwInfo;