intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-29 09:03:14 +08:00
Code Issues Packages Projects Releases Wiki Activity

Remove not needed virtual methods from event class

Browse Source 
Related-To: NEO-6262

Signed-off-by: Zbigniew Zdanowicz <zbigniew.zdanowicz@intel.com>
This commit is contained in:
Zbigniew Zdanowicz
2021-12-08 11:12:14 +00:00
committed by Compute-Runtime-Automation
parent 1f09d40e5a
commit f47814fb32
5 changed files with 56 additions and 45 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -63,17 +63,31 @@ struct Event : _ze_event_handle_t {
virtual void setPacketsInUse(uint32_t value) = 0;
uint32_t getCurrKernelDataIndex() const { return kernelCount - 1; }
virtual size_t getContextStartOffset() const = 0;
virtual size_t getContextEndOffset() const = 0;
virtual size_t getGlobalStartOffset() const = 0;
virtual size_t getGlobalEndOffset() const = 0;
virtual size_t getSinglePacketSize() const = 0;
virtual size_t getTimestampSizeInDw() const = 0;
size_t getContextStartOffset() const {
return contextStartOffset;
}
size_t getContextEndOffset() const {
return contextEndOffset;
}
size_t getGlobalStartOffset() const {
return globalStartOffset;
}
size_t getGlobalEndOffset() const {
return globalEndOffset;
}
size_t getSinglePacketSize() const {
return singlePacketSize;
}
size_t getTimestampSizeInDw() const {
return timestampSizeInDw;
}
void setEventTimestampFlag(bool timestampFlag) {
isTimestampEvent = timestampFlag;
}
bool isEventTimestampFlagSet() { return isTimestampEvent; }
virtual ze_result_t hostEventSetValue(uint32_t eventValue) = 0;
void *hostAddress = nullptr;
uint32_t kernelCount = 1u;
ze_event_scope_flags_t signalScope = 0u;
ze_event_scope_flags_t waitScope = 0u;
uint64_t globalStartTS;
uint64_t globalEndTS;
@@ -83,16 +97,20 @@ struct Event : _ze_event_handle_t {
// Metric streamer instance associated with the event.
MetricStreamer *metricStreamer = nullptr;
NEO::CommandStreamReceiver *csr = nullptr;
void *hostAddress = nullptr;
void setEventTimestampFlag(bool timestampFlag) {
isTimestampEvent = timestampFlag;
}
ze_event_scope_flags_t signalScope = 0u;
ze_event_scope_flags_t waitScope = 0u;
bool isEventTimestampFlagSet() { return isTimestampEvent; }
uint32_t kernelCount = 1u;
protected:
uint64_t gpuAddress;
NEO::GraphicsAllocation *allocation = nullptr;
size_t contextStartOffset = 0u;
size_t contextEndOffset = 0u;
size_t globalStartOffset = 0u;
size_t globalEndOffset = 0u;
size_t timestampSizeInDw = 0u;
size_t singlePacketSize = 0u;
bool isTimestampEvent = false;
};
@@ -110,7 +128,14 @@ template <typename TagSizeT>
struct EventImp : public Event {
EventImp(EventPool *eventPool, int index, Device *device)
: device(device), index(index), eventPool(eventPool) {}
: device(device), index(index), eventPool(eventPool) {
contextStartOffset = NEO::TimestampPackets<TagSizeT>::getContextStartOffset();
contextEndOffset = NEO::TimestampPackets<TagSizeT>::getContextEndOffset();
globalStartOffset = NEO::TimestampPackets<TagSizeT>::getGlobalStartOffset();
globalEndOffset = NEO::TimestampPackets<TagSizeT>::getGlobalEndOffset();
timestampSizeInDw = (sizeof(TagSizeT) / 4);
singlePacketSize = NEO::TimestampPackets<TagSizeT>::getSinglePacketSize();
}
~EventImp() override {}
@@ -133,12 +158,6 @@ struct EventImp : public Event {
uint64_t getPacketAddress(Device *device) override;
uint32_t getPacketsInUse() override;
void setPacketsInUse(uint32_t value) override;
size_t getTimestampSizeInDw() const override { return (sizeof(TagSizeT) / 4); };
size_t getContextStartOffset() const override { return NEO::TimestampPackets<TagSizeT>::getContextStartOffset(); }
size_t getContextEndOffset() const override { return NEO::TimestampPackets<TagSizeT>::getContextEndOffset(); }
size_t getGlobalStartOffset() const override { return NEO::TimestampPackets<TagSizeT>::getGlobalStartOffset(); }
size_t getGlobalEndOffset() const override { return NEO::TimestampPackets<TagSizeT>::getGlobalEndOffset(); }
size_t getSinglePacketSize() const override { return NEO::TimestampPackets<TagSizeT>::getSinglePacketSize(); };
ze_result_t hostEventSetValue(uint32_t eventValue) override;
std::unique_ptr<KernelEventCompletionData<TagSizeT>[]> kernelEventCompletionData;

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

@@ -83,7 +83,7 @@ void EventImp<TagSizeT>::assignKernelEventCompletionData(void *address) {
packetsToCopy = kernelEventCompletionData[i].getPacketsUsed();
for (uint32_t packetId = 0; packetId < packetsToCopy; packetId++) {
kernelEventCompletionData[i].assignDataToAllTimestamps(packetId, address);
address = ptrOffset(address, NEO::TimestampPackets<TagSizeT>::getSinglePacketSize());
address = ptrOffset(address, singlePacketSize);
}
}
}
@@ -152,11 +152,11 @@ ze_result_t EventImp<TagSizeT>::hostEventSetValueTimestamps(TagSizeT eventVal) {
for (uint32_t i = 0; i < kernelCount; i++) {
uint32_t packetsToSet = kernelEventCompletionData[i].getPacketsUsed();
for (uint32_t j = 0; j < packetsToSet; j++) {
eventTsSetFunc(baseAddr + NEO::TimestampPackets<TagSizeT>::getContextStartOffset());
eventTsSetFunc(baseAddr + NEO::TimestampPackets<TagSizeT>::getGlobalStartOffset());
eventTsSetFunc(baseAddr + NEO::TimestampPackets<TagSizeT>::getContextEndOffset());
eventTsSetFunc(baseAddr + NEO::TimestampPackets<TagSizeT>::getGlobalEndOffset());
baseAddr += NEO::TimestampPackets<TagSizeT>::getSinglePacketSize();
eventTsSetFunc(baseAddr + contextStartOffset);
eventTsSetFunc(baseAddr + globalStartOffset);
eventTsSetFunc(baseAddr + contextEndOffset);
eventTsSetFunc(baseAddr + globalEndOffset);
baseAddr += singlePacketSize;
}
}
assignKernelEventCompletionData(hostAddress);
@@ -347,7 +347,7 @@ uint64_t EventImp<TagSizeT>::getPacketAddress(Device *device) {
uint64_t address = getGpuAddress(device);
for (uint32_t i = 0; i < kernelCount - 1; i++) {
address += kernelEventCompletionData[i].getPacketsUsed() *
NEO::TimestampPackets<TagSizeT>::getSinglePacketSize();
singlePacketSize;
}
return address;
}

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

@@ -12,7 +12,7 @@ namespace ult {
Mock<Event>::Mock() : mockAllocation(0, NEO::GraphicsAllocation::AllocationType::INTERNAL_HOST_MEMORY,
&memory, reinterpret_cast<uint64_t>(&memory), 0, sizeof(memory),
MemoryPool::System4KBPages) { allocation = &mockAllocation; }
MemoryPool::System4KBPages) {}
Mock<Event>::~Mock() {}

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

@@ -18,7 +18,6 @@ namespace ult {
template <>
struct WhiteBox<::L0::Event> : public ::L0::Event {
using BaseClass = ::L0::Event;
using BaseClass::allocation;
};
using Event = WhiteBox<::L0::Event>;
@@ -46,8 +45,6 @@ struct Mock<Event> : public Event {
// Fake an allocation for event memory
alignas(16) uint32_t memory = -1;
NEO::GraphicsAllocation mockAllocation;
using Event::allocation;
};
template <>

17
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_5.cpp
View File

@@ -32,7 +32,12 @@ class MockEvent : public ::L0::Event {
mockAllocation.reset(new NEO::MockGraphicsAllocation(0, NEO::GraphicsAllocation::AllocationType::INTERNAL_HOST_MEMORY,
reinterpret_cast<void *>(0x1234), 0x1000, 0, sizeof(uint32_t),
MemoryPool::System4KBPages));
gpuAddress = mockAllocation->getGpuAddress();
this->timestampSizeInDw = 1;
this->contextStartOffset = 0;
this->contextEndOffset = 4;
this->globalStartOffset = 8;
this->globalEndOffset = 12;
this->singlePacketSize = 16;
}
NEO::GraphicsAllocation &getAllocation(L0::Device *device) override {
return *mockAllocation.get();
@@ -68,16 +73,6 @@ class MockEvent : public ::L0::Event {
return ZE_RESULT_SUCCESS;
}
size_t getTimestampSizeInDw() const override {
return 1;
}
size_t getContextStartOffset() const override { return 0; }
size_t getContextEndOffset() const override { return 4; }
size_t getGlobalStartOffset() const override { return 8; }
size_t getGlobalEndOffset() const override { return 12; }
size_t getSinglePacketSize() const override { return 16; };
uint32_t getPacketsInUse() override { return 1; }
void resetPackets() override{};
void setPacketsInUse(uint32_t value) override{};