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

disable event query status optimization for ipc events 

Related-To: NEO-7636

Signed-off-by: Zbigniew Zdanowicz <zbigniew.zdanowicz@intel.com>
This commit is contained in:
Zbigniew Zdanowicz 2023-01-17 12:40:06 +00:00 committed by Compute-Runtime-Automation
parent 272254569d
commit 9441e1c510
5 changed files with 78 additions and 7 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -218,6 +218,7 @@ struct Event : _ze_event_handle_t {
bool isTimestampEvent = false;
bool usingContextEndOffset = false;
bool signalAllEventPackets = false;
bool isFromIpcPool = false;
};
template <typename TagSizeT>

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

@ -43,6 +43,7 @@ Event *Event::create(EventPool *eventPool, const ze_event_desc_t *desc, Device *
event->csr = csr;
event->maxKernelCount = eventPool->getMaxKernelCount();
event->maxPacketCount = eventPool->getEventMaxPackets();
event->isFromIpcPool = eventPool->isImportedIpcPool;
event->kernelEventCompletionData =
std::make_unique<KernelEventCompletionData<TagSizeT>[]>(event->maxKernelCount);
@ -180,7 +181,7 @@ ze_result_t EventImp<TagSizeT>::queryStatus() {
this->csr->downloadAllocation(this->getAllocation(this->device));
}
if (isAlreadyCompleted()) {
if (!this->isFromIpcPool && isAlreadyCompleted()) {
return ZE_RESULT_SUCCESS;
} else {
return queryStatusEventPackets();

2
level_zero/core/test/unit_tests/mocks/mock_event.h
View File

@ -22,6 +22,7 @@ struct WhiteBox<::L0::Event> : public ::L0::Event {
using BaseClass::csr;
using BaseClass::Event;
using BaseClass::hostAddress;
using BaseClass::isFromIpcPool;
using BaseClass::l3FlushAppliedOnKernel;
using BaseClass::maxKernelCount;
using BaseClass::signalAllEventPackets;
@ -71,6 +72,7 @@ class MockEvent : public ::L0::Event {
using ::L0::Event::gpuEndTimestamp;
using ::L0::Event::gpuStartTimestamp;
using ::L0::Event::isCompleted;
using ::L0::Event::isFromIpcPool;
using ::L0::Event::l3FlushAppliedOnKernel;
using ::L0::Event::maxKernelCount;
using ::L0::Event::signalAllEventPackets;

71
level_zero/core/test/unit_tests/sources/event/test_event.cpp
View File

@ -301,9 +301,18 @@ class MemoryManagerEventPoolIPCMock : public NEO::MockMemoryManager {
alloc->isShareableHostMemory = true;
multiGraphicsAllocation.addAllocation(alloc);
return reinterpret_cast<void *>(alloc->getUnderlyingBuffer());
};
char buffer[64];
}
GraphicsAllocation *createGraphicsAllocationFromSharedHandle(osHandle handle, const AllocationProperties &properties, bool requireSpecificBitness, bool isHostIpcAllocation, bool reuseSharedAllocation) override {
if (callParentCreateGraphicsAllocationFromSharedHandle) {
return NEO::MockMemoryManager::createGraphicsAllocationFromSharedHandle(handle, properties, requireSpecificBitness, isHostIpcAllocation, reuseSharedAllocation);
}
alloc = new NEO::MockGraphicsAllocation(&buffer, sizeof(buffer));
alloc->isShareableHostMemory = true;
return alloc;
}
char buffer[256];
NEO::MockGraphicsAllocation *alloc;
bool callParentCreateGraphicsAllocationFromSharedHandle = true;
};
using EventPoolIPCHandleTests = Test<DeviceFixture>;
@ -610,6 +619,64 @@ TEST_F(EventPoolIPCHandleTests, GivenEventPoolWithIPCEventFlagAndHostMemoryThenS
EXPECT_FALSE(allocation->getGraphicsAllocation(device->getNEODevice()->getRootDeviceIndex())->isShareableHostMemory);
}
TEST_F(EventPoolIPCHandleTests, GivenIpcEventPoolWhenCreatingEventFromIpcPoolThenExpectIpcFlag) {
uint32_t numEvents = 1;
ze_event_pool_desc_t eventPoolDesc = {
ZE_STRUCTURE_TYPE_EVENT_POOL_DESC,
nullptr,
ZE_EVENT_POOL_FLAG_HOST_VISIBLE | ZE_EVENT_POOL_FLAG_IPC,
numEvents};
auto deviceHandle = device->toHandle();
ze_result_t result = ZE_RESULT_SUCCESS;
auto curMemoryManager = driverHandle->getMemoryManager();
MemoryManagerEventPoolIPCMock *mockMemoryManager = new MemoryManagerEventPoolIPCMock(*neoDevice->executionEnvironment);
mockMemoryManager->callParentCreateGraphicsAllocationFromSharedHandle = false;
driverHandle->setMemoryManager(mockMemoryManager);
auto eventPool = EventPool::create(driverHandle.get(), context, 1, &deviceHandle, &eventPoolDesc, result);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
ASSERT_NE(nullptr, eventPool);
ze_ipc_event_pool_handle_t ipcHandle = {};
ze_result_t res = eventPool->getIpcHandle(&ipcHandle);
EXPECT_EQ(res, ZE_RESULT_SUCCESS);
ze_event_pool_handle_t ipcEventPoolHandle = {};
res = context->openEventPoolIpcHandle(ipcHandle, &ipcEventPoolHandle);
ASSERT_EQ(res, ZE_RESULT_SUCCESS);
auto ipcEventPool = L0::EventPool::fromHandle(ipcEventPoolHandle);
const ze_event_desc_t eventDesc = {
ZE_STRUCTURE_TYPE_EVENT_DESC,
nullptr,
0,
0,
0};
auto event = whiteboxCast(Event::create<uint32_t>(ipcEventPool, &eventDesc, device));
ASSERT_NE(nullptr, event);
EXPECT_TRUE(event->isFromIpcPool);
res = ipcEventPool->closeIpcHandle();
EXPECT_EQ(res, ZE_RESULT_SUCCESS);
uint32_t *data = static_cast<uint32_t *>(event->getCompletionFieldHostAddress());
for (uint32_t i = 0; i < event->getPacketsInUse(); i++) {
*data = L0::Event::STATE_CLEARED;
data = ptrOffset(data, event->getSinglePacketSize());
}
event->setIsCompleted();
result = event->queryStatus();
EXPECT_EQ(ZE_RESULT_NOT_READY, result);
event->destroy();
res = eventPool->destroy();
EXPECT_EQ(res, ZE_RESULT_SUCCESS);
delete mockMemoryManager;
driverHandle->setMemoryManager(curMemoryManager);
}
using EventPoolOpenIPCHandleFailTests = Test<DeviceFixture>;
TEST_F(EventPoolOpenIPCHandleFailTests, givenFailureToAllocateMemoryWhenOpeningIpcHandleForEventPoolThenInvalidArgumentIsReturned) {

8
level_zero/core/test/unit_tests/xe_hpc_core/test_event_xe_hpc_core.cpp
View File

@ -14,9 +14,9 @@
namespace L0 {
namespace ult {
class MemoryManagerEventPoolIPCMock : public NEO::MockMemoryManager {
class MemoryManagerEventPoolIPCMockXeHpc : public NEO::MockMemoryManager {
public:
MemoryManagerEventPoolIPCMock(NEO::ExecutionEnvironment &executionEnvironment) : NEO::MockMemoryManager(executionEnvironment) {}
MemoryManagerEventPoolIPCMockXeHpc(NEO::ExecutionEnvironment &executionEnvironment) : NEO::MockMemoryManager(executionEnvironment) {}
void *createMultiGraphicsAllocationInSystemMemoryPool(RootDeviceIndicesContainer &rootDeviceIndices, AllocationProperties &properties, NEO::MultiGraphicsAllocation &multiGraphicsAllocation) override {
alloc = new NEO::MockGraphicsAllocation(&buffer, sizeof(buffer));
alloc->isShareableHostMemory = true;
@ -40,7 +40,7 @@ HWTEST2_F(EventPoolIPCHandleHpcCoreTests, whenGettingIpcHandleForEventPoolWithDe
auto deviceHandle = device->toHandle();
ze_result_t result = ZE_RESULT_SUCCESS;
auto curMemoryManager = driverHandle->getMemoryManager();
MemoryManagerEventPoolIPCMock *mockMemoryManager = new MemoryManagerEventPoolIPCMock(*neoDevice->executionEnvironment);
MemoryManagerEventPoolIPCMockXeHpc *mockMemoryManager = new MemoryManagerEventPoolIPCMockXeHpc(*neoDevice->executionEnvironment);
driverHandle->setMemoryManager(mockMemoryManager);
auto eventPool = EventPool::create(driverHandle.get(), context, 1, &deviceHandle, &eventPoolDesc, result);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
@ -81,7 +81,7 @@ HWTEST2_F(EventPoolIPCHandleHpcCoreTests, whenOpeningIpcHandleForEventPoolWithHo
auto deviceHandle = device->toHandle();
ze_result_t result = ZE_RESULT_SUCCESS;
auto curMemoryManager = driverHandle->getMemoryManager();
MemoryManagerEventPoolIPCMock *mockMemoryManager = new MemoryManagerEventPoolIPCMock(*neoDevice->executionEnvironment);
MemoryManagerEventPoolIPCMockXeHpc *mockMemoryManager = new MemoryManagerEventPoolIPCMockXeHpc(*neoDevice->executionEnvironment);
driverHandle->setMemoryManager(mockMemoryManager);
auto eventPool = EventPool::create(driverHandle.get(), context, 1, &deviceHandle, &eventPoolDesc, result);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);