Propagate exec buffer error to L0 API level on Xe HPC

JablonskiMateusz · Compute-Runtime-Automation · commit bae873507f85 · 2022-11-09T13:09:22.000+01:00
This change makes that drm file is opened in nonblocking mode for prelim kernels. In such case when calling exec buffer ioctl and get EAGAIN (aka EWOULDBLOCK) we may return error to API level Related-To: NEO-7144 Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com> Source: 9816f81
diff --git a/level_zero/core/source/cmdqueue/cmdqueue_hw.inl b/level_zero/core/source/cmdqueue/cmdqueue_hw.inl
@@ -1117,6 +1117,9 @@ ze_result_t CommandQueueHw<gfxCoreFamily>::handleSubmissionAndCompletionResults(
         if (submitRet == NEO::SubmissionStatus::OUT_OF_MEMORY) {
             completionRet = ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY;
         }
+        if (submitRet == NEO::SubmissionStatus::OUT_OF_HOST_MEMORY) {
+            completionRet = ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+        }
     }
 
     return completionRet;
diff --git a/level_zero/core/test/unit_tests/mocks/mock_cmdqueue.h b/level_zero/core/test/unit_tests/mocks/mock_cmdqueue.h
@@ -92,13 +92,17 @@ struct MockCommandQueueHw : public L0::CommandQueueHw<gfxCoreFamily> {
 
     NEO::SubmissionStatus submitBatchBuffer(size_t offset, NEO::ResidencyContainer &residencyContainer, void *endingCmdPtr, bool isCooperative) override {
         residencyContainerSnapshot = residencyContainer;
+        if (submitBatchBufferReturnValue.has_value()) {
+            return *submitBatchBufferReturnValue;
+        }
         return BaseClass::submitBatchBuffer(offset, residencyContainer, endingCmdPtr, isCooperative);
     }
 
     uint32_t synchronizedCalled = 0;
     NEO::ResidencyContainer residencyContainerSnapshot;
     ze_result_t synchronizeReturnValue{ZE_RESULT_SUCCESS};
     std::optional<NEO::WaitStatus> reserveLinearStreamSizeReturnValue{};
+    std::optional<NEO::SubmissionStatus> submitBatchBufferReturnValue{};
 };
 
 struct Deleter {
@@ -108,4 +112,4 @@ struct Deleter {
 };
 
 } // namespace ult
-} // namespace L0
+} // namespace L0
diff --git a/level_zero/core/test/unit_tests/os_interface/linux/CMakeLists.txt b/level_zero/core/test/unit_tests/os_interface/linux/CMakeLists.txt
@@ -0,0 +1,12 @@
+#
+# Copyright (C) 2022 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+#
+
+if(UNIX)
+  target_sources(${TARGET_NAME} PRIVATE
+                 ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+                 ${CMAKE_CURRENT_SOURCE_DIR}/cmdqueue_linux_tests.cpp
+  )
+endif()
diff --git a/level_zero/core/test/unit_tests/os_interface/linux/cmdqueue_linux_tests.cpp b/level_zero/core/test/unit_tests/os_interface/linux/cmdqueue_linux_tests.cpp
@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 2022 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "shared/test/common/helpers/ult_hw_config.h"
+#include "shared/test/common/helpers/variable_backup.h"
+#include "shared/test/common/libult/create_command_stream.h"
+#include "shared/test/common/libult/linux/drm_mock.h"
+#include "shared/test/common/test_macros/hw_test.h"
+
+#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
+#include "level_zero/core/test/unit_tests/mocks/mock_cmdlist.h"
+#include "level_zero/core/test/unit_tests/mocks/mock_cmdqueue.h"
+#include "level_zero/core/test/unit_tests/mocks/mock_kernel.h"
+
+namespace L0 {
+namespace ult {
+
+struct CommandQueueLinuxTests : public Test<DeviceFixture> {
+
+    void SetUp() override {
+        VariableBackup<UltHwConfig> backup(&ultHwConfig);
+        ultHwConfig.useMockedPrepareDeviceEnvironmentsFunc = false;
+        ultHwConfig.useHwCsr = true;
+        ultHwConfig.forceOsAgnosticMemoryManager = false;
+        auto *executionEnvironment = new NEO::ExecutionEnvironment();
+        prepareDeviceEnvironments(*executionEnvironment);
+        executionEnvironment->initializeMemoryManager();
+        setupWithExecutionEnvironment(*executionEnvironment);
+    }
+};
+
+HWTEST2_F(CommandQueueLinuxTests, givenExecBufferErrorOnXeHpcWhenExecutingCommandListsThenOutOfHostMemoryIsReturned, IsXeHpcCore) {
+    auto drm = neoDevice->getRootDeviceEnvironment().osInterface->getDriverModel()->as<DrmMock>();
+
+    drm->execBufferResult = -1;
+    drm->baseErrno = false;
+    drm->errnoRetVal = EWOULDBLOCK;
+    const ze_command_queue_desc_t desc = {};
+    ze_result_t returnValue;
+    auto commandQueue = whiteboxCast(CommandQueue::create(productFamily,
+                                                          device,
+                                                          neoDevice->getDefaultEngine().commandStreamReceiver,
+                                                          &desc,
+                                                          false,
+                                                          false,
+                                                          returnValue));
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, returnValue);
+    Mock<Kernel> kernel;
+    kernel.immutableData.isaGraphicsAllocation.reset(neoDevice->getMemoryManager()->allocateGraphicsMemoryWithProperties(
+        {device->getRootDeviceIndex(), MemoryConstants::pageSize, NEO::AllocationType::KERNEL_ISA, neoDevice->getDeviceBitfield()}));
+    kernel.immutableData.device = device;
+
+    auto commandList = std::unique_ptr<CommandList>(whiteboxCast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
+    EXPECT_EQ(ZE_RESULT_SUCCESS, returnValue);
+    ASSERT_NE(nullptr, commandList);
+
+    ze_group_count_t dispatchFunctionArguments{1, 1, 1};
+    CmdListKernelLaunchParams launchParams = {};
+    commandList->appendLaunchKernel(kernel.toHandle(), &dispatchFunctionArguments, nullptr, 0, nullptr, launchParams);
+
+    ze_command_list_handle_t cmdListHandles[1] = {commandList->toHandle()};
+
+    returnValue = commandQueue->executeCommandLists(1, cmdListHandles, nullptr, false);
+    EXPECT_EQ(ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY, returnValue);
+    commandQueue->destroy();
+    neoDevice->getMemoryManager()->freeGraphicsMemory(kernel.immutableData.isaGraphicsAllocation.release());
+}
+} // namespace ult
+} // namespace L0
diff --git a/level_zero/core/test/unit_tests/sources/cmdqueue/test_cmdqueue_1.cpp b/level_zero/core/test/unit_tests/sources/cmdqueue/test_cmdqueue_1.cpp
@@ -357,6 +357,30 @@ HWTEST2_F(CommandQueueCreate, givenLogicalStateHelperAndImmediateCmdListWhenExec
     commandQueue->destroy();
 }
 
+HWTEST2_F(CommandQueueCreate, givenOutOfHostMemoryErrorFromSubmitBatchBufferWhenExecutingCommandListsThenOutOfHostMemoryIsReturned, IsAtLeastSkl) {
+    const ze_command_queue_desc_t desc = {};
+    auto commandQueue = new MockCommandQueueHw<gfxCoreFamily>(device, neoDevice->getDefaultEngine().commandStreamReceiver, &desc);
+    commandQueue->initialize(false, false);
+    commandQueue->submitBatchBufferReturnValue = NEO::SubmissionStatus::OUT_OF_HOST_MEMORY;
+
+    Mock<Kernel> kernel;
+    kernel.immutableData.device = device;
+
+    ze_result_t returnValue;
+    auto commandList = std::unique_ptr<CommandList>(whiteboxCast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
+    ASSERT_NE(nullptr, commandList);
+
+    ze_group_count_t dispatchFunctionArguments{1, 1, 1};
+    CmdListKernelLaunchParams launchParams = {};
+    commandList->appendLaunchKernel(kernel.toHandle(), &dispatchFunctionArguments, nullptr, 0, nullptr, launchParams);
+
+    ze_command_list_handle_t cmdListHandles[1] = {commandList->toHandle()};
+
+    const auto result = commandQueue->executeCommandLists(1, cmdListHandles, nullptr, false);
+    EXPECT_EQ(ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY, result);
+    commandQueue->destroy();
+}
+
 HWTEST2_F(CommandQueueCreate, givenGpuHangInReservingLinearStreamWhenExecutingCommandListsThenDeviceLostIsReturned, IsSKL) {
     const ze_command_queue_desc_t desc = {};
     MockCommandQueueHw<gfxCoreFamily> commandQueue(device, neoDevice->getDefaultEngine().commandStreamReceiver, &desc);
diff --git a/shared/source/command_stream/submission_status.h b/shared/source/command_stream/submission_status.h
@@ -14,6 +14,7 @@ enum class SubmissionStatus : uint32_t {
     SUCCESS = 0,
     FAILED,
     OUT_OF_MEMORY,
+    OUT_OF_HOST_MEMORY,
     UNSUPPORTED,
     DEVICE_UNINITIALIZED,
 };
diff --git a/shared/source/os_interface/hw_info_config.h b/shared/source/os_interface/hw_info_config.h
@@ -139,6 +139,7 @@ class HwInfoConfig {
     virtual bool isPrefetcherDisablingInDirectSubmissionRequired() const = 0;
     virtual bool isStatefulAddressingModeSupported() const = 0;
     virtual bool isPlatformQuerySupported() const = 0;
+    virtual bool isNonBlockingGpuSubmissionSupported() const = 0;
 
     virtual bool getFrontEndPropertyScratchSizeSupport() const = 0;
     virtual bool getFrontEndPropertyPrivateScratchSizeSupport() const = 0;
@@ -275,6 +276,7 @@ class HwInfoConfigHw : public HwInfoConfig {
     bool isPrefetcherDisablingInDirectSubmissionRequired() const override;
     bool isStatefulAddressingModeSupported() const override;
     bool isPlatformQuerySupported() const override;
+    bool isNonBlockingGpuSubmissionSupported() const override;
 
     bool getFrontEndPropertyScratchSizeSupport() const override;
     bool getFrontEndPropertyPrivateScratchSizeSupport() const override;
diff --git a/shared/source/os_interface/hw_info_config.inl b/shared/source/os_interface/hw_info_config.inl
@@ -501,6 +501,11 @@ bool HwInfoConfigHw<gfxProduct>::isPlatformQuerySupported() const {
     return false;
 }
 
+template <PRODUCT_FAMILY gfxProduct>
+bool HwInfoConfigHw<gfxProduct>::isNonBlockingGpuSubmissionSupported() const {
+    return false;
+}
+
 template <PRODUCT_FAMILY gfxProduct>
 void HwInfoConfigHw<gfxProduct>::fillScmPropertiesSupportStructureBase(StateComputeModePropertiesSupport &propertiesSupport) {
     propertiesSupport.coherencyRequired = getScmPropertyCoherencyRequiredSupport();
diff --git a/shared/source/os_interface/linux/drm_command_stream_bdw_and_later.inl b/shared/source/os_interface/linux/drm_command_stream_bdw_and_later.inl
@@ -20,6 +20,9 @@ SubmissionStatus DrmCommandStreamReceiver<GfxFamily>::flushInternal(const BatchB
     int ret = this->exec(batchBuffer, 0u, static_cast<const OsContextLinux *>(osContext)->getDrmContextIds()[0], 0);
 
     if (ret) {
+        if (ret == EWOULDBLOCK) {
+            return SubmissionStatus::OUT_OF_HOST_MEMORY;
+        }
         return SubmissionStatus::FAILED;
     }
     return SubmissionStatus::SUCCESS;
diff --git a/shared/source/os_interface/linux/drm_command_stream_xehp_and_later.inl b/shared/source/os_interface/linux/drm_command_stream_xehp_and_later.inl
@@ -39,6 +39,9 @@ SubmissionStatus DrmCommandStreamReceiver<GfxFamily>::flushInternal(const BatchB
 
             int ret = this->exec(batchBuffer, tileIterator, drmContextIds[contextIndex], contextIndex);
             if (ret) {
+                if (ret == EWOULDBLOCK) {
+                    return SubmissionStatus::OUT_OF_HOST_MEMORY;
+                }
                 return SubmissionStatus::FAILED;
             }
 
diff --git a/shared/source/os_interface/linux/ioctl_helper.cpp b/shared/source/os_interface/linux/ioctl_helper.cpp
@@ -372,4 +372,5 @@ std::string IoctlHelper::getFileForMaxMemoryFrequencyOfSubDevice(int subDeviceId
 bool IoctlHelper::checkIfIoctlReinvokeRequired(int error, DrmIoctl ioctlRequest) const {
     return (error == EINTR || error == EAGAIN || error == EBUSY || error == -EBUSY);
 }
+
 } // namespace NEO
diff --git a/shared/source/os_interface/linux/ioctl_helper.h b/shared/source/os_interface/linux/ioctl_helper.h
@@ -210,7 +210,7 @@ class IoctlHelperImpl : public IoctlHelperUpstream {
 
 class IoctlHelperPrelim20 : public IoctlHelper {
   public:
-    using IoctlHelper::IoctlHelper;
+    IoctlHelperPrelim20(Drm &drmArg);
 
     bool initialize() override;
     bool isSetPairAvailable() override;
@@ -259,6 +259,9 @@ class IoctlHelperPrelim20 : public IoctlHelper {
     std::string getIoctlString(DrmIoctl ioctlRequest) const override;
     bool checkIfIoctlReinvokeRequired(int error, DrmIoctl ioctlRequest) const override;
     bool getFabricLatency(uint32_t fabricId, uint32_t &latency, uint32_t &bandwidth) override;
+
+  protected:
+    bool handleExecBufferInNonBlockMode = false;
 };
 
 } // namespace NEO
diff --git a/shared/source/os_interface/linux/ioctl_helper_prelim.cpp b/shared/source/os_interface/linux/ioctl_helper_prelim.cpp
@@ -6,15 +6,19 @@
  */
 
 #include "shared/source/debug_settings/debug_settings_manager.h"
+#include "shared/source/execution_environment/root_device_environment.h"
 #include "shared/source/helpers/debug_helpers.h"
 #include "shared/source/helpers/hw_helper.h"
 #include "shared/source/helpers/hw_info.h"
 #include "shared/source/helpers/ptr_math.h"
 #include "shared/source/helpers/string.h"
+#include "shared/source/os_interface/hw_info_config.h"
 #include "shared/source/os_interface/linux/cache_info.h"
+#include "shared/source/os_interface/linux/drm_neo.h"
 #include "shared/source/os_interface/linux/drm_wrappers.h"
 #include "shared/source/os_interface/linux/i915_prelim.h"
 #include "shared/source/os_interface/linux/ioctl_helper.h"
+#include "shared/source/os_interface/linux/sys_calls.h"
 
 #include <algorithm>
 #include <cerrno>
@@ -25,6 +29,15 @@
 
 namespace NEO {
 
+IoctlHelperPrelim20::IoctlHelperPrelim20(Drm &drmArg) : IoctlHelper(drmArg) {
+    auto hwHelper = HwInfoConfig::get(this->drm.getRootDeviceEnvironment().getHardwareInfo()->platform.eProductFamily);
+    if (hwHelper && hwHelper->isNonBlockingGpuSubmissionSupported()) {
+        handleExecBufferInNonBlockMode = true;
+        auto fileDescriptor = this->drm.getFileDescriptor();
+        SysCalls::fcntl(fileDescriptor, F_SETFL, SysCalls::fcntl(fileDescriptor, F_GETFL) | O_NONBLOCK);
+    }
+};
+
 bool IoctlHelperPrelim20::isSetPairAvailable() {
     int setPairSupported = 0;
     GetParam getParam{};
@@ -649,6 +662,12 @@ bool IoctlHelperPrelim20::checkIfIoctlReinvokeRequired(int error, DrmIoctl ioctl
     switch (ioctlRequest) {
     case DrmIoctl::DebuggerOpen:
         return (error == EINTR || error == EAGAIN);
+    case DrmIoctl::GemExecbuffer2:
+        if (handleExecBufferInNonBlockMode) {
+            return (error == EINTR || error == EBUSY || error == -EBUSY);
+        } else {
+            return IoctlHelper::checkIfIoctlReinvokeRequired(error, ioctlRequest);
+        }
     default:
         break;
     }
diff --git a/shared/source/os_interface/linux/sys_calls.h b/shared/source/os_interface/linux/sys_calls.h
@@ -29,5 +29,7 @@ ssize_t pwrite(int fd, const void *buf, size_t count, off_t offset);
 void *mmap(void *addr, size_t size, int prot, int flags, int fd, off_t off);
 int munmap(void *addr, size_t size);
 ssize_t read(int fd, void *buf, size_t count);
+int fcntl(int fd, int cmd);
+int fcntl(int fd, int cmd, int arg);
 } // namespace SysCalls
 } // namespace NEO
diff --git a/shared/source/os_interface/linux/sys_calls_linux.cpp b/shared/source/os_interface/linux/sys_calls_linux.cpp
@@ -93,5 +93,12 @@ ssize_t read(int fd, void *buf, size_t count) {
     return ::read(fd, buf, count);
 }
 
+int fcntl(int fd, int cmd) {
+    return ::fcntl(fd, cmd);
+}
+int fcntl(int fd, int cmd, int arg) {
+    return ::fcntl(fd, cmd, arg);
+}
+
 } // namespace SysCalls
 } // namespace NEO
diff --git a/shared/source/xe_hpc_core/linux/hw_info_config_pvc.cpp b/shared/source/xe_hpc_core/linux/hw_info_config_pvc.cpp
@@ -33,28 +33,6 @@ const std::map<std::string, std::pair<uint32_t, uint32_t>> guidUuidOffsetMap = {
 #include "shared/source/xe_hpc_core/os_agnostic_hw_info_config_xe_hpc_core.inl"
 #include "shared/source/xe_hpc_core/pvc/os_agnostic_hw_info_config_pvc.inl"
 
-template <>
-int HwInfoConfigHw<gfxProduct>::configureHardwareCustom(HardwareInfo *hwInfo, OSInterface *osIface) {
-    enableCompression(hwInfo);
-
-    hwInfo->featureTable.flags.ftr57bGPUAddressing = (hwInfo->capabilityTable.gpuAddressSpace == maxNBitValue(57));
-
-    enableBlitterOperationsSupport(hwInfo);
-
-    hwInfo->featureTable.flags.ftrRcsNode = false;
-    if (DebugManager.flags.NodeOrdinal.get() == static_cast<int32_t>(aub_stream::EngineType::ENGINE_CCCS)) {
-        hwInfo->featureTable.flags.ftrRcsNode = true;
-    }
-
-    auto &kmdNotifyProperties = hwInfo->capabilityTable.kmdNotifyProperties;
-    kmdNotifyProperties.enableKmdNotify = true;
-    kmdNotifyProperties.delayKmdNotifyMicroseconds = 150;
-    kmdNotifyProperties.enableQuickKmdSleepForDirectSubmission = true;
-    kmdNotifyProperties.delayQuickKmdSleepForDirectSubmissionMicroseconds = 20;
-
-    return 0;
-}
-
 template <>
 uint64_t HwInfoConfigHw<gfxProduct>::getDeviceMemoryPhysicalSizeInBytes(const OSInterface *osIface, uint32_t subDeviceIndex) {
 
@@ -94,5 +72,10 @@ uint64_t HwInfoConfigHw<gfxProduct>::getDeviceMemoryMaxBandWidthInBytesPerSecond
     return memoryMaxClkRateInMhz * 1000 * 1000 * numberOfHbmStacksPerTile * memoryBusWidth / 8;
 }
 
+} // namespace NEO
+
+#include "shared/source/xe_hpc_core/linux/hw_info_config_xe_hpc_core.inl"
+
+namespace NEO {
 template class HwInfoConfigHw<gfxProduct>;
 } // namespace NEO
diff --git a/shared/source/xe_hpc_core/linux/hw_info_config_xe_hpc_core.inl b/shared/source/xe_hpc_core/linux/hw_info_config_xe_hpc_core.inl
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2022 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "shared/source/debug_settings/debug_settings_manager.h"
+#include "shared/source/helpers/constants.h"
+#include "shared/source/os_interface/hw_info_config.h"
+
+namespace NEO {
+template <>
+int HwInfoConfigHw<gfxProduct>::configureHardwareCustom(HardwareInfo *hwInfo, OSInterface *osIface) {
+    enableCompression(hwInfo);
+
+    hwInfo->featureTable.flags.ftr57bGPUAddressing = (hwInfo->capabilityTable.gpuAddressSpace == maxNBitValue(57));
+
+    enableBlitterOperationsSupport(hwInfo);
+
+    hwInfo->featureTable.flags.ftrRcsNode = false;
+    if (DebugManager.flags.NodeOrdinal.get() == static_cast<int32_t>(aub_stream::EngineType::ENGINE_CCCS)) {
+        hwInfo->featureTable.flags.ftrRcsNode = true;
+    }
+
+    auto &kmdNotifyProperties = hwInfo->capabilityTable.kmdNotifyProperties;
+    kmdNotifyProperties.enableKmdNotify = true;
+    kmdNotifyProperties.delayKmdNotifyMicroseconds = 150;
+    kmdNotifyProperties.enableQuickKmdSleepForDirectSubmission = true;
+    kmdNotifyProperties.delayQuickKmdSleepForDirectSubmissionMicroseconds = 20;
+
+    return 0;
+}
+
+template <>
+bool HwInfoConfigHw<gfxProduct>::isNonBlockingGpuSubmissionSupported() const {
+    return true;
+}
+
+} // namespace NEO
diff --git a/shared/test/common/libult/linux/drm_mock.cpp b/shared/test/common/libult/linux/drm_mock.cpp
@@ -196,7 +196,7 @@ int DrmMock::ioctl(DrmIoctl request, void *arg) {
         for (uint32_t i = 0; i < execbuf->getBufferCount(); i++) {
             this->receivedBos.push_back(execObjects[i]);
         }
-        return 0;
+        return execBufferResult;
     }
     if (request == DrmIoctl::GemUserptr) {
         ioctlCount.gemUserptr++;
diff --git a/shared/test/common/libult/linux/drm_mock.h b/shared/test/common/libult/linux/drm_mock.h
diff --git a/shared/test/common/os_interface/linux/drm_buffer_object_fixture.h b/shared/test/common/os_interface/linux/drm_buffer_object_fixture.h
diff --git a/shared/test/common/os_interface/linux/drm_command_stream_fixture.h b/shared/test/common/os_interface/linux/drm_command_stream_fixture.h
diff --git a/shared/test/common/os_interface/linux/sys_calls_linux_ult.cpp b/shared/test/common/os_interface/linux/sys_calls_linux_ult.cpp
diff --git a/shared/test/common/os_interface/linux/sys_calls_linux_ult.h b/shared/test/common/os_interface/linux/sys_calls_linux_ult.h
diff --git a/shared/test/unit_test/os_interface/linux/drm_command_stream_tests.cpp b/shared/test/unit_test/os_interface/linux/drm_command_stream_tests.cpp
diff --git a/shared/test/unit_test/os_interface/linux/drm_command_stream_tests_1.cpp b/shared/test/unit_test/os_interface/linux/drm_command_stream_tests_1.cpp
diff --git a/shared/test/unit_test/os_interface/linux/ioctl_helper_tests_prelim.cpp b/shared/test/unit_test/os_interface/linux/ioctl_helper_tests_prelim.cpp

Original file line number	Diff line number	Diff line change
`@@ -1117,6 +1117,9 @@ ze_result_t CommandQueueHw<gfxCoreFamily>::handleSubmissionAndCompletionResults(`
`1117`	`1117`	`if (submitRet == NEO::SubmissionStatus::OUT_OF_MEMORY) {`
`1118`	`1118`	`completionRet = ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY;`
`1119`	`1119`	`}`
	`1120`	`+ if (submitRet == NEO::SubmissionStatus::OUT_OF_HOST_MEMORY) {`
	`1121`	`+ completionRet = ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;`
	`1122`	`+ }`
`1120`	`1123`	`}`
`1121`	`1124`
`1122`	`1125`	`return completionRet;`
Original file line number	Diff line number	Diff line change
`@@ -20,6 +20,9 @@ SubmissionStatus DrmCommandStreamReceiver<GfxFamily>::flushInternal(const BatchB`
`20`	`20`	`int ret = this->exec(batchBuffer, 0u, static_cast<const OsContextLinux *>(osContext)->getDrmContextIds()[0], 0);`
`21`	`21`
`22`	`22`	`if (ret) {`
	`23`	`+ if (ret == EWOULDBLOCK) {`
	`24`	`+ return SubmissionStatus::OUT_OF_HOST_MEMORY;`
	`25`	`+ }`
`23`	`26`	`return SubmissionStatus::FAILED;`
`24`	`27`	`}`
`25`	`28`	`return SubmissionStatus::SUCCESS;`
Original file line number	Diff line number	Diff line change
`@@ -39,6 +39,9 @@ SubmissionStatus DrmCommandStreamReceiver<GfxFamily>::flushInternal(const BatchB`
`39`	`39`
`40`	`40`	`int ret = this->exec(batchBuffer, tileIterator, drmContextIds[contextIndex], contextIndex);`
`41`	`41`	`if (ret) {`
	`42`	`+ if (ret == EWOULDBLOCK) {`
	`43`	`+ return SubmissionStatus::OUT_OF_HOST_MEMORY;`
	`44`	`+ }`
`42`	`45`	`return SubmissionStatus::FAILED;`
`43`	`46`	`}`
`44`	`47`