Media
/
compute-runtime
mirror of https://github.com/intel/compute-runtime.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Dont use default engine in immediate cmdlist 

Related-To: NEO-4913

Change-Id: I15b5bb700e37ea49c34931bc81de7314ec1ac4dc
Signed-off-by: Maciej Plewka <maciej.plewka@intel.com>
This commit is contained in:
Maciej Plewka 2020-08-07 13:57:18 +02:00 committed by sys_ocldev
parent d49a7293e2
commit 8785f5acb2
7 changed files with 111 additions and 32 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
level_zero/core/source/cmdlist/cmdlist_imp.cpp
View File

@ -68,16 +68,8 @@ CommandList *CommandList::createImmediate(uint32_t productFamily, Device *device
const ze_command_queue_desc_t *desc,
bool internalUsage, bool isCopyOnly) {
auto deviceImp = static_cast<DeviceImp *>(device);
NEO::CommandStreamReceiver *csr = nullptr;
if (internalUsage) {
csr = deviceImp->neoDevice->getInternalEngine().commandStreamReceiver;
} else if (isCopyOnly) {
auto &selectorCopyEngine = deviceImp->neoDevice->getDeviceById(0)->getSelectorCopyEngine();
csr = deviceImp->neoDevice->getDeviceById(0)->getEngine(NEO::EngineHelpers::getBcsEngineType(deviceImp->neoDevice->getHardwareInfo(), selectorCopyEngine), false).commandStreamReceiver;
} else {
csr = deviceImp->neoDevice->getDefaultEngine().commandStreamReceiver;
}
device->getCsrForOrdinalAndIndex(&csr, desc->ordinal, desc->index);
auto commandQueue = CommandQueue::create(productFamily, device, csr, desc, isCopyOnly);
if (!commandQueue) {

2
level_zero/core/source/device/device.h
View File

@ -122,6 +122,8 @@ struct Device : _ze_device_handle_t {
virtual NEO::GraphicsAllocation *allocateMemoryFromHostPtr(const void *buffer, size_t size) = 0;
virtual void setSysmanHandle(SysmanDevice *pSysmanDevice) = 0;
virtual SysmanDevice *getSysmanHandle() = 0;
virtual ze_result_t getCsrForOrdinalAndIndex(NEO::CommandStreamReceiver **csr, uint32_t ordinal, uint32_t index) = 0;
virtual ze_result_t mapOrdinalForAvailableEngineGroup(uint32_t *ordinal) = 0;
};
} // namespace L0

67
level_zero/core/source/device/device_imp.cpp
View File

@ -95,11 +95,9 @@ ze_result_t DeviceImp::createCommandList(const ze_command_list_desc_t *desc,
ze_result_t DeviceImp::createCommandListImmediate(const ze_command_queue_desc_t *desc,
ze_command_list_handle_t *phCommandList) {
auto productFamily = neoDevice->getHardwareInfo().platform.eProductFamily;
bool useBliter = false;
if (desc->ordinal == static_cast<uint32_t>(NEO::EngineGroupType::Copy)) {
useBliter = true;
}
uint32_t engineGroupIndex = desc->ordinal;
mapOrdinalForAvailableEngineGroup(&engineGroupIndex);
bool useBliter = engineGroupIndex == static_cast<uint32_t>(NEO::EngineGroupType::Copy);
*phCommandList = CommandList::createImmediate(productFamily, this, desc, false, useBliter);
return ZE_RESULT_SUCCESS;
@ -110,22 +108,12 @@ ze_result_t DeviceImp::createCommandQueue(const ze_command_queue_desc_t *desc,
auto productFamily = neoDevice->getHardwareInfo().platform.eProductFamily;
NEO::CommandStreamReceiver *csr = nullptr;
bool useBliter = desc->ordinal == static_cast<uint32_t>(NEO::EngineGroupType::Copy);
if (desc->ordinal >= static_cast<uint32_t>(NEO::EngineGroupType::MaxEngineGroups)) {
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
if (this->getNEODevice()->getNumAvailableDevices() > 1) {
if (desc->index >= this->neoDevice->getDeviceById(0)->getEngineGroups()[desc->ordinal].size()) {
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
csr = this->neoDevice->getDeviceById(0)->getEngineGroups()[desc->ordinal][desc->index].commandStreamReceiver;
} else {
if (desc->index >= this->neoDevice->getEngineGroups()[desc->ordinal].size()) {
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
csr = this->neoDevice->getEngineGroups()[desc->ordinal][desc->index].commandStreamReceiver;
uint32_t engineGroupIndex = desc->ordinal;
mapOrdinalForAvailableEngineGroup(&engineGroupIndex);
bool useBliter = engineGroupIndex == static_cast<uint32_t>(NEO::EngineGroupType::Copy);
auto ret = getCsrForOrdinalAndIndex(&csr, desc->ordinal, desc->index);
if (ret != ZE_RESULT_SUCCESS) {
return ret;
}
UNRECOVERABLE_IF(csr == nullptr);
@ -725,4 +713,41 @@ NEO::GraphicsAllocation *DeviceImp::allocateMemoryFromHostPtr(const void *buffer
return allocation;
}
ze_result_t DeviceImp::getCsrForOrdinalAndIndex(NEO::CommandStreamReceiver **csr, uint32_t ordinal, uint32_t index) {
if (ordinal >= static_cast<uint32_t>(NEO::EngineGroupType::MaxEngineGroups)) {
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
uint32_t engineGroupIndex = ordinal;
auto ret = mapOrdinalForAvailableEngineGroup(&engineGroupIndex);
if (ret != ZE_RESULT_SUCCESS) {
return ret;
}
if (this->getNEODevice()->getNumAvailableDevices() > 1) {
if (index >= this->neoDevice->getDeviceById(0)->getEngineGroups()[engineGroupIndex].size()) {
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
*csr = this->neoDevice->getDeviceById(0)->getEngineGroups()[engineGroupIndex][index].commandStreamReceiver;
} else {
if (index >= this->neoDevice->getEngineGroups()[engineGroupIndex].size()) {
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
*csr = this->neoDevice->getEngineGroups()[engineGroupIndex][index].commandStreamReceiver;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t DeviceImp::mapOrdinalForAvailableEngineGroup(uint32_t *ordinal) {
auto engines = this->getNEODevice()->getEngineGroups();
uint32_t numNonEmptyGroups = 0;
uint32_t i = 0;
for (; i < engines.size() && numNonEmptyGroups <= *ordinal; i++) {
if (!engines[i].empty()) {
numNonEmptyGroups++;
}
}
if (*ordinal + 1 > numNonEmptyGroups) {
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
*ordinal = i - 1;
return ZE_RESULT_SUCCESS;
};
} // namespace L0

3
level_zero/core/source/device/device_imp.h
View File

@ -67,6 +67,7 @@ struct DeviceImp : public Device {
void setDriverHandle(DriverHandle *driverHandle) override;
NEO::PreemptionMode getDevicePreemptionMode() const override;
const NEO::DeviceInfo &getDeviceInfo() const override;
NEO::Device *getNEODevice() override;
void activateMetricGroups() override;
void processAdditionalKernelProperties(NEO::HwHelper &hwHelper, ze_device_module_properties_t *pKernelProperties);
@ -77,6 +78,8 @@ struct DeviceImp : public Device {
NEO::GraphicsAllocation *allocateMemoryFromHostPtr(const void *buffer, size_t size) override;
void setSysmanHandle(SysmanDevice *pSysman) override;
SysmanDevice *getSysmanHandle() override;
ze_result_t getCsrForOrdinalAndIndex(NEO::CommandStreamReceiver **csr, uint32_t ordinal, uint32_t index) override;
ze_result_t mapOrdinalForAvailableEngineGroup(uint32_t *ordinal) override;
NEO::Device *neoDevice = nullptr;
bool isSubdevice = false;

7
level_zero/core/test/unit_tests/mocks/mock_device.h
View File

@ -252,6 +252,13 @@ struct Mock<Device> : public Device {
getSysmanHandle,
(),
(override));
ze_result_t getCsrForOrdinalAndIndex(NEO::CommandStreamReceiver **csr, uint32_t ordinal, uint32_t index) override {
return ZE_RESULT_SUCCESS;
}
ze_result_t mapOrdinalForAvailableEngineGroup(uint32_t *ordinal) override {
return ZE_RESULT_SUCCESS;
}
};
template <>

25
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_1.cpp
View File

@ -179,6 +179,31 @@ TEST_F(CommandListCreate, whenCreatingImmediateCommandListThenItHasImmediateComm
EXPECT_NE(nullptr, commandList->cmdQImmediate);
}
TEST_F(CommandListCreate, givenQueueDescriptionwhenCreatingImmediateCommandListForEveryEnigneThenItHasImmediateCommandQueueCreated) {
auto engines = neoDevice->getEngineGroups();
uint32_t numaAvailableEngineGroups = 0;
for (uint32_t ordinal = 0; ordinal < static_cast<uint32_t>(NEO::EngineGroupType::MaxEngineGroups); ordinal++) {
if (engines[ordinal].size()) {
numaAvailableEngineGroups++;
}
}
for (uint32_t ordinal = 0; ordinal < numaAvailableEngineGroups; ordinal++) {
uint32_t engineGroupIndex = ordinal;
device->mapOrdinalForAvailableEngineGroup(&engineGroupIndex);
for (uint32_t index = 0; index < engines[engineGroupIndex].size(); index++) {
ze_command_queue_desc_t desc = {};
desc.ordinal = ordinal;
desc.index = index;
std::unique_ptr<L0::CommandList> commandList(CommandList::createImmediate(productFamily, device, &desc, false, false));
ASSERT_NE(nullptr, commandList);
EXPECT_EQ(device, commandList->device);
EXPECT_EQ(CommandList::CommandListType::TYPE_IMMEDIATE, commandList->cmdListType);
EXPECT_NE(nullptr, commandList->cmdQImmediate);
}
}
}
TEST_F(CommandListCreate, givenInvalidProductFamilyThenReturnsNullPointer) {
std::unique_ptr<L0::CommandList> commandList(CommandList::create(IGFX_UNKNOWN, device, false));
EXPECT_EQ(nullptr, commandList);

29
level_zero/core/test/unit_tests/sources/cmdqueue/test_cmdqueue.cpp
View File

@ -273,9 +273,17 @@ TEST_F(ContextCreateCommandQueueTest, givenCallToContextCreateCommandQueueThenCa
HWTEST_F(ContextCreateCommandQueueTest, givenEveryPossibleGroupIndexWhenCreatingCommandQueueThenCommandQueueIsCreated) {
ze_command_queue_handle_t commandQueue = {};
for (uint32_t ordinal = 0; ordinal < static_cast<uint32_t>(NEO::EngineGroupType::MaxEngineGroups); ordinal++) {
auto engines = neoDevice->getEngineGroups();
for (uint32_t index = 0; index < engines[ordinal].size(); index++) {
uint32_t numaAvailableEngineGroups = 0;
for (uint32_t ordinal = 0; ordinal < static_cast<uint32_t>(NEO::EngineGroupType::MaxEngineGroups); ordinal++) {
if (engines[ordinal].size()) {
numaAvailableEngineGroups++;
}
}
for (uint32_t ordinal = 0; ordinal < numaAvailableEngineGroups; ordinal++) {
uint32_t engineGroupIndex = ordinal;
device->mapOrdinalForAvailableEngineGroup(&engineGroupIndex);
for (uint32_t index = 0; index < engines[engineGroupIndex].size(); index++) {
ze_command_queue_desc_t desc = {};
desc.ordinal = ordinal;
desc.index = index;
@ -288,6 +296,23 @@ HWTEST_F(ContextCreateCommandQueueTest, givenEveryPossibleGroupIndexWhenCreating
}
}
HWTEST_F(ContextCreateCommandQueueTest, givenOrdinalBigerThanAvailableEnginesWhenCreatingCommandQueueThenInvalidArgReturned) {
ze_command_queue_handle_t commandQueue = {};
auto engines = neoDevice->getEngineGroups();
uint32_t numaAvailableEngineGroups = 0;
for (uint32_t ordinal = 0; ordinal < static_cast<uint32_t>(NEO::EngineGroupType::MaxEngineGroups); ordinal++) {
if (engines[ordinal].size()) {
numaAvailableEngineGroups++;
}
}
ze_command_queue_desc_t desc = {};
desc.ordinal = numaAvailableEngineGroups;
desc.index = 0;
ze_result_t res = context->createCommandQueue(device, &desc, &commandQueue);
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, res);
EXPECT_EQ(nullptr, commandQueue);
}
using CommandQueueSynchronizeTest = Test<ContextFixture>;
HWTEST_F(CommandQueueSynchronizeTest, givenCallToSynchronizeThenCorrectEnableTimeoutAndTimeoutValuesAreUsed) {