diff --git a/level_zero/core/source/CMakeLists.txt b/level_zero/core/source/CMakeLists.txt
index e5eb6dd305..d0963bc1ac 100644
--- a/level_zero/core/source/CMakeLists.txt
+++ b/level_zero/core/source/CMakeLists.txt
@@ -44,6 +44,7 @@ set(L0_RUNTIME_SOURCES
     ${CMAKE_CURRENT_SOURCE_DIR}/driver/driver_imp.h
     ${CMAKE_CURRENT_SOURCE_DIR}/driver/host_pointer_manager.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/driver/host_pointer_manager.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/event/event_impl.inl
     ${CMAKE_CURRENT_SOURCE_DIR}/event/event.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/event/event.h
     ${CMAKE_CURRENT_SOURCE_DIR}/fence/fence.cpp
diff --git a/level_zero/core/source/event/event.cpp b/level_zero/core/source/event/event.cpp
index 0d65efa693..7e9da1ad19 100644
--- a/level_zero/core/source/event/event.cpp
+++ b/level_zero/core/source/event/event.cpp
@@ -24,6 +24,7 @@
 #include "level_zero/core/source/device/device.h"
 #include "level_zero/core/source/device/device_imp.h"
 #include "level_zero/core/source/driver/driver_handle_imp.h"
+#include "level_zero/core/source/event/event_impl.inl"
 #include "level_zero/tools/source/metrics/metric.h"
 
 #include <set>
@@ -110,289 +111,16 @@ ze_result_t EventPoolImp::createEvent(const ze_event_desc_t *desc, ze_event_hand
     if (desc->index > (getNumEvents() - 1)) {
         return ZE_RESULT_ERROR_INVALID_ARGUMENT;
     }
-    *phEvent = Event::create(this, desc, this->getDevice());
+    *phEvent = Event::create<uint32_t>(this, desc, this->getDevice());
 
     return ZE_RESULT_SUCCESS;
 }
 
-uint64_t EventImp::getGpuAddress(Device *device) {
-    auto alloc = eventPool->getAllocation().getGraphicsAllocation(device->getNEODevice()->getRootDeviceIndex());
-    return (alloc->getGpuAddress() + (index * eventPool->getEventSize()));
-}
-
-Event *Event::create(EventPool *eventPool, const ze_event_desc_t *desc, Device *device) {
-    auto event = new EventImp(eventPool, desc->index, device);
-    UNRECOVERABLE_IF(event == nullptr);
-
-    if (eventPool->isEventPoolUsedForTimestamp) {
-        event->isTimestampEvent = true;
-        event->kernelTimestampsData = std::make_unique<NEO::TimestampPackets<uint32_t>[]>(EventPacketsCount::maxKernelSplit);
-    }
-
-    auto alloc = eventPool->getAllocation().getGraphicsAllocation(device->getNEODevice()->getRootDeviceIndex());
-
-    uint64_t baseHostAddr = reinterpret_cast<uint64_t>(alloc->getUnderlyingBuffer());
-    event->hostAddress = reinterpret_cast<void *>(baseHostAddr + (desc->index * eventPool->getEventSize()));
-    event->signalScope = desc->signal;
-    event->waitScope = desc->wait;
-    event->csr = static_cast<DeviceImp *>(device)->neoDevice->getDefaultEngine().commandStreamReceiver;
-    event->reset();
-
-    return event;
-}
-
-NEO::GraphicsAllocation &EventImp::getAllocation(Device *device) {
-    return *this->eventPool->getAllocation().getGraphicsAllocation(device->getNEODevice()->getRootDeviceIndex());
-}
-
-void Event::resetPackets() {
-    for (uint32_t i = 0; i < kernelCount; i++) {
-        kernelTimestampsData[i].setPacketsUsed(1);
-    }
-    kernelCount = 1;
-}
-
-uint32_t Event::getPacketsInUse() {
-    if (isTimestampEvent) {
-        uint32_t packetsInUse = 0;
-        for (uint32_t i = 0; i < kernelCount; i++) {
-            packetsInUse += kernelTimestampsData[i].getPacketsUsed();
-        };
-        return packetsInUse;
-    } else {
-        return 1;
-    }
-}
-
-void Event::setPacketsInUse(uint32_t value) {
-    kernelTimestampsData[getCurrKernelDataIndex()].setPacketsUsed(value);
-};
-
-uint64_t Event::getPacketAddress(Device *device) {
-    uint64_t address = getGpuAddress(device);
-    if (isTimestampEvent && kernelCount > 1) {
-        for (uint32_t i = 0; i < kernelCount - 1; i++) {
-            address += kernelTimestampsData[i].getPacketsUsed() *
-                       NEO::TimestampPackets<uint32_t>::getSinglePacketSize();
-        }
-    }
-    return address;
-}
-
-ze_result_t EventImp::calculateProfilingData() {
-    globalStartTS = kernelTimestampsData[0].getGlobalStartValue(0);
-    globalEndTS = kernelTimestampsData[0].getGlobalEndValue(0);
-    contextStartTS = kernelTimestampsData[0].getContextStartValue(0);
-    contextEndTS = kernelTimestampsData[0].getContextEndValue(0);
-
-    for (uint32_t i = 0; i < kernelCount; i++) {
-        for (auto packetId = 0u; packetId < kernelTimestampsData[i].getPacketsUsed(); packetId++) {
-            if (globalStartTS > kernelTimestampsData[i].getGlobalStartValue(packetId)) {
-                globalStartTS = kernelTimestampsData[i].getGlobalStartValue(packetId);
-            }
-            if (contextStartTS > kernelTimestampsData[i].getContextStartValue(packetId)) {
-                contextStartTS = kernelTimestampsData[i].getContextStartValue(packetId);
-            }
-            if (contextEndTS < kernelTimestampsData[i].getContextEndValue(packetId)) {
-                contextEndTS = kernelTimestampsData[i].getContextEndValue(packetId);
-            }
-            if (globalEndTS < kernelTimestampsData[i].getGlobalEndValue(packetId)) {
-                globalEndTS = kernelTimestampsData[i].getGlobalEndValue(packetId);
-            }
-        }
-    }
-
-    return ZE_RESULT_SUCCESS;
-}
-
-void EventImp::assignTimestampData(void *address) {
-    for (uint32_t i = 0; i < kernelCount; i++) {
-        uint32_t packetsToCopy = kernelTimestampsData[i].getPacketsUsed();
-        for (uint32_t packetId = 0; packetId < packetsToCopy; packetId++) {
-            kernelTimestampsData[i].assignDataToAllTimestamps(packetId, address);
-            address = ptrOffset(address, NEO::TimestampPackets<uint32_t>::getSinglePacketSize());
-        }
-    }
-}
-
 ze_result_t Event::destroy() {
     delete this;
     return ZE_RESULT_SUCCESS;
 }
 
-ze_result_t EventImp::queryStatusKernelTimestamp() {
-    assignTimestampData(hostAddress);
-    for (uint32_t i = 0; i < kernelCount; i++) {
-        uint32_t packetsToCheck = kernelTimestampsData[i].getPacketsUsed();
-        for (uint32_t packetId = 0; packetId < packetsToCheck; packetId++) {
-            if (kernelTimestampsData[i].getContextEndValue(packetId) == Event::STATE_CLEARED) {
-                return ZE_RESULT_NOT_READY;
-            }
-        }
-    }
-    return ZE_RESULT_SUCCESS;
-}
-
-ze_result_t EventImp::queryStatus() {
-    uint64_t *hostAddr = static_cast<uint64_t *>(hostAddress);
-    uint32_t queryVal = Event::STATE_CLEARED;
-    ze_result_t retVal;
-
-    if (metricStreamer != nullptr) {
-        *hostAddr = metricStreamer->getNotificationState();
-    }
-    this->csr->downloadAllocations();
-    if (isTimestampEvent) {
-        return queryStatusKernelTimestamp();
-    }
-    memcpy_s(static_cast<void *>(&queryVal), sizeof(uint32_t), static_cast<void *>(hostAddr), sizeof(uint32_t));
-    retVal = (queryVal == Event::STATE_CLEARED) ? ZE_RESULT_NOT_READY : ZE_RESULT_SUCCESS;
-
-    if (retVal == ZE_RESULT_NOT_READY) {
-        return retVal;
-    }
-
-    if (updateTaskCountEnabled) {
-        this->csr->flushTagUpdate();
-        updateTaskCountEnabled = false;
-    }
-
-    return retVal;
-}
-
-ze_result_t EventImp::hostEventSetValueTimestamps(uint32_t eventVal) {
-
-    auto baseAddr = reinterpret_cast<uint64_t>(hostAddress);
-    auto signalScopeFlag = this->signalScope;
-
-    auto eventTsSetFunc = [&eventVal, &signalScopeFlag](auto tsAddr) {
-        auto tsptr = reinterpret_cast<void *>(tsAddr);
-
-        memcpy_s(tsptr, sizeof(uint32_t), static_cast<void *>(&eventVal), sizeof(uint32_t));
-        if (!signalScopeFlag) {
-            NEO::CpuIntrinsics::clFlush(tsptr);
-        }
-    };
-    for (uint32_t i = 0; i < kernelCount; i++) {
-        uint32_t packetsToSet = kernelTimestampsData[i].getPacketsUsed();
-        for (uint32_t i = 0; i < packetsToSet; i++) {
-            eventTsSetFunc(baseAddr + NEO::TimestampPackets<uint32_t>::getContextStartOffset());
-            eventTsSetFunc(baseAddr + NEO::TimestampPackets<uint32_t>::getGlobalStartOffset());
-            eventTsSetFunc(baseAddr + NEO::TimestampPackets<uint32_t>::getContextEndOffset());
-            eventTsSetFunc(baseAddr + NEO::TimestampPackets<uint32_t>::getGlobalEndOffset());
-            baseAddr += NEO::TimestampPackets<uint32_t>::getSinglePacketSize();
-        }
-    }
-    assignTimestampData(hostAddress);
-
-    return ZE_RESULT_SUCCESS;
-}
-
-ze_result_t EventImp::hostEventSetValue(uint32_t eventVal) {
-    if (isTimestampEvent) {
-        return hostEventSetValueTimestamps(eventVal);
-    }
-
-    auto hostAddr = static_cast<uint64_t *>(hostAddress);
-    UNRECOVERABLE_IF(hostAddr == nullptr);
-    memcpy_s(static_cast<void *>(hostAddr), sizeof(uint32_t), static_cast<void *>(&eventVal), sizeof(uint32_t));
-
-    if (updateTaskCountEnabled) {
-        this->csr->flushTagUpdate();
-        updateTaskCountEnabled = false;
-    }
-
-    NEO::CpuIntrinsics::clFlush(hostAddr);
-
-    return ZE_RESULT_SUCCESS;
-}
-
-ze_result_t EventImp::hostSignal() {
-    return hostEventSetValue(Event::STATE_SIGNALED);
-}
-
-ze_result_t EventImp::hostSynchronize(uint64_t timeout) {
-    std::chrono::high_resolution_clock::time_point time1, time2;
-    uint64_t timeDiff = 0;
-
-    ze_result_t ret = ZE_RESULT_NOT_READY;
-
-    if (this->csr->getType() == NEO::CommandStreamReceiverType::CSR_AUB) {
-        return ZE_RESULT_SUCCESS;
-    }
-
-    if (timeout == 0) {
-        return queryStatus();
-    }
-
-    time1 = std::chrono::high_resolution_clock::now();
-    while (true) {
-        ret = queryStatus();
-        if (ret == ZE_RESULT_SUCCESS) {
-            return ret;
-        }
-
-        NEO::WaitUtils::waitFunction(nullptr, 0u);
-
-        if (timeout == std::numeric_limits<uint32_t>::max()) {
-            continue;
-        }
-
-        time2 = std::chrono::high_resolution_clock::now();
-        timeDiff = std::chrono::duration_cast<std::chrono::nanoseconds>(time2 - time1).count();
-
-        if (timeDiff >= timeout) {
-            break;
-        }
-    }
-
-    return ret;
-}
-
-ze_result_t EventImp::reset() {
-    if (isTimestampEvent) {
-        kernelCount = EventPacketsCount::maxKernelSplit;
-        for (uint32_t i = 0; i < kernelCount; i++) {
-            kernelTimestampsData[i].setPacketsUsed(NEO::TimestampPacketSizeControl::preferredPacketCount);
-        }
-        hostEventSetValue(Event::STATE_INITIAL);
-        resetPackets();
-        return ZE_RESULT_SUCCESS;
-    } else {
-        return hostEventSetValue(Event::STATE_INITIAL);
-    }
-}
-
-ze_result_t EventImp::queryKernelTimestamp(ze_kernel_timestamp_result_t *dstptr) {
-
-    ze_kernel_timestamp_result_t &result = *dstptr;
-
-    if (queryStatus() != ZE_RESULT_SUCCESS) {
-        return ZE_RESULT_NOT_READY;
-    }
-
-    assignTimestampData(hostAddress);
-    calculateProfilingData();
-
-    auto eventTsSetFunc = [&](uint64_t &timestampFieldToCopy, uint64_t &timestampFieldForWriting) {
-        memcpy_s(&(timestampFieldForWriting), sizeof(uint64_t), static_cast<void *>(&timestampFieldToCopy), sizeof(uint64_t));
-    };
-
-    if (!NEO::HwHelper::get(device->getHwInfo().platform.eRenderCoreFamily).useOnlyGlobalTimestamps()) {
-        eventTsSetFunc(contextStartTS, result.context.kernelStart);
-        eventTsSetFunc(globalStartTS, result.global.kernelStart);
-        eventTsSetFunc(contextEndTS, result.context.kernelEnd);
-        eventTsSetFunc(globalEndTS, result.global.kernelEnd);
-    } else {
-        eventTsSetFunc(globalStartTS, result.context.kernelStart);
-        eventTsSetFunc(globalStartTS, result.global.kernelStart);
-        eventTsSetFunc(globalEndTS, result.context.kernelEnd);
-        eventTsSetFunc(globalEndTS, result.global.kernelEnd);
-    }
-
-    return ZE_RESULT_SUCCESS;
-}
-
 EventPool *EventPool::create(DriverHandle *driver, Context *context, uint32_t numDevices,
                              ze_device_handle_t *phDevices,
                              const ze_event_pool_desc_t *desc) {
diff --git a/level_zero/core/source/event/event.h b/level_zero/core/source/event/event.h
index cc29633428..c004d82136 100644
--- a/level_zero/core/source/event/event.h
+++ b/level_zero/core/source/event/event.h
@@ -42,6 +42,7 @@ struct Event : _ze_event_handle_t {
         STATE_INITIAL = STATE_CLEARED
     };
 
+    template <typename TagSizeT>
     static Event *create(EventPool *eventPool, const ze_event_desc_t *desc, Device *device);
 
     static Event *fromHandle(ze_event_handle_t handle) { return static_cast<Event *>(handle); }
@@ -51,11 +52,11 @@ struct Event : _ze_event_handle_t {
     virtual NEO::GraphicsAllocation &getAllocation(Device *device) = 0;
 
     virtual uint64_t getGpuAddress(Device *device) = 0;
-    uint32_t getPacketsInUse();
-    uint64_t getPacketAddress(Device *device);
-    void resetPackets();
+    virtual uint32_t getPacketsInUse() = 0;
+    virtual uint64_t getPacketAddress(Device *device) = 0;
+    virtual void resetPackets() = 0;
     void *getHostAddress() { return hostAddress; }
-    void setPacketsInUse(uint32_t value);
+    virtual void setPacketsInUse(uint32_t value) = 0;
     uint32_t getCurrKernelDataIndex() const { return kernelCount - 1; }
     void *hostAddress = nullptr;
     uint32_t kernelCount = 1u;
@@ -64,7 +65,6 @@ struct Event : _ze_event_handle_t {
     bool isTimestampEvent = false;
     bool updateTaskCountEnabled = false;
 
-    std::unique_ptr<NEO::TimestampPackets<uint32_t>[]> kernelTimestampsData = nullptr;
     uint64_t globalStartTS;
     uint64_t globalEndTS;
     uint64_t contextStartTS;
@@ -79,6 +79,7 @@ struct Event : _ze_event_handle_t {
     NEO::GraphicsAllocation *allocation = nullptr;
 };
 
+template <typename TagSizeT>
 struct EventImp : public Event {
     EventImp(EventPool *eventPool, int index, Device *device)
         : device(device), index(index), eventPool(eventPool) {}
@@ -99,6 +100,13 @@ struct EventImp : public Event {
 
     uint64_t getGpuAddress(Device *device) override;
 
+    void resetPackets() override;
+    uint64_t getPacketAddress(Device *device) override;
+    uint32_t getPacketsInUse() override;
+    void setPacketsInUse(uint32_t value) override;
+
+    std::unique_ptr<NEO::TimestampPackets<TagSizeT>[]> kernelTimestampsData;
+
     Device *device;
     int index;
     EventPool *eventPool;
@@ -107,7 +115,7 @@ struct EventImp : public Event {
     ze_result_t calculateProfilingData();
     ze_result_t queryStatusKernelTimestamp();
     ze_result_t hostEventSetValue(uint32_t eventValue);
-    ze_result_t hostEventSetValueTimestamps(uint32_t eventVal);
+    ze_result_t hostEventSetValueTimestamps(TagSizeT eventVal);
     void assignTimestampData(void *address);
 };
 
diff --git a/level_zero/core/source/event/event_impl.inl b/level_zero/core/source/event/event_impl.inl
new file mode 100644
index 0000000000..e331c8b48e
--- /dev/null
+++ b/level_zero/core/source/event/event_impl.inl
@@ -0,0 +1,301 @@
+/*
+ * Copyright (C) 2021 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "level_zero/core/source/event/event.h"
+
+namespace L0 {
+template <typename TagSizeT>
+Event *Event::create(EventPool *eventPool, const ze_event_desc_t *desc, Device *device) {
+    auto event = new EventImp<TagSizeT>(eventPool, desc->index, device);
+    UNRECOVERABLE_IF(event == nullptr);
+
+    if (eventPool->isEventPoolUsedForTimestamp) {
+        event->isTimestampEvent = true;
+        event->kernelTimestampsData = std::make_unique<NEO::TimestampPackets<TagSizeT>[]>(EventPacketsCount::maxKernelSplit);
+    }
+
+    auto alloc = eventPool->getAllocation().getGraphicsAllocation(device->getNEODevice()->getRootDeviceIndex());
+
+    uint64_t baseHostAddr = reinterpret_cast<uint64_t>(alloc->getUnderlyingBuffer());
+    event->hostAddress = reinterpret_cast<void *>(baseHostAddr + (desc->index * eventPool->getEventSize()));
+    event->signalScope = desc->signal;
+    event->waitScope = desc->wait;
+    event->csr = static_cast<DeviceImp *>(device)->neoDevice->getDefaultEngine().commandStreamReceiver;
+    event->reset();
+
+    return event;
+}
+
+template <typename TagSizeT>
+uint64_t EventImp<TagSizeT>::getGpuAddress(Device *device) {
+    auto alloc = eventPool->getAllocation().getGraphicsAllocation(device->getNEODevice()->getRootDeviceIndex());
+    return (alloc->getGpuAddress() + (index * eventPool->getEventSize()));
+}
+
+template <typename TagSizeT>
+NEO::GraphicsAllocation &EventImp<TagSizeT>::getAllocation(Device *device) {
+    return *this->eventPool->getAllocation().getGraphicsAllocation(device->getNEODevice()->getRootDeviceIndex());
+}
+
+template <typename TagSizeT>
+ze_result_t EventImp<TagSizeT>::calculateProfilingData() {
+    globalStartTS = kernelTimestampsData[0].getGlobalStartValue(0);
+    globalEndTS = kernelTimestampsData[0].getGlobalEndValue(0);
+    contextStartTS = kernelTimestampsData[0].getContextStartValue(0);
+    contextEndTS = kernelTimestampsData[0].getContextEndValue(0);
+
+    for (uint32_t i = 0; i < kernelCount; i++) {
+        for (auto packetId = 0u; packetId < kernelTimestampsData[i].getPacketsUsed(); packetId++) {
+            if (globalStartTS > kernelTimestampsData[i].getGlobalStartValue(packetId)) {
+                globalStartTS = kernelTimestampsData[i].getGlobalStartValue(packetId);
+            }
+            if (contextStartTS > kernelTimestampsData[i].getContextStartValue(packetId)) {
+                contextStartTS = kernelTimestampsData[i].getContextStartValue(packetId);
+            }
+            if (contextEndTS < kernelTimestampsData[i].getContextEndValue(packetId)) {
+                contextEndTS = kernelTimestampsData[i].getContextEndValue(packetId);
+            }
+            if (globalEndTS < kernelTimestampsData[i].getGlobalEndValue(packetId)) {
+                globalEndTS = kernelTimestampsData[i].getGlobalEndValue(packetId);
+            }
+        }
+    }
+
+    return ZE_RESULT_SUCCESS;
+}
+
+template <typename TagSizeT>
+void EventImp<TagSizeT>::assignTimestampData(void *address) {
+    for (uint32_t i = 0; i < kernelCount; i++) {
+        uint32_t packetsToCopy = kernelTimestampsData[i].getPacketsUsed();
+        for (uint32_t packetId = 0; packetId < packetsToCopy; packetId++) {
+            kernelTimestampsData[i].assignDataToAllTimestamps(packetId, address);
+            address = ptrOffset(address, NEO::TimestampPackets<TagSizeT>::getSinglePacketSize());
+        }
+    }
+}
+
+template <typename TagSizeT>
+ze_result_t EventImp<TagSizeT>::queryStatusKernelTimestamp() {
+    assignTimestampData(hostAddress);
+    for (uint32_t i = 0; i < kernelCount; i++) {
+        uint32_t packetsToCheck = kernelTimestampsData[i].getPacketsUsed();
+        for (uint32_t packetId = 0; packetId < packetsToCheck; packetId++) {
+            if (kernelTimestampsData[i].getContextEndValue(packetId) == Event::STATE_CLEARED) {
+                return ZE_RESULT_NOT_READY;
+            }
+        }
+    }
+    return ZE_RESULT_SUCCESS;
+}
+
+template <typename TagSizeT>
+ze_result_t EventImp<TagSizeT>::queryStatus() {
+    uint64_t *hostAddr = static_cast<uint64_t *>(hostAddress);
+    uint32_t queryVal = Event::STATE_CLEARED;
+    ze_result_t retVal;
+
+    if (metricStreamer != nullptr) {
+        *hostAddr = metricStreamer->getNotificationState();
+    }
+    this->csr->downloadAllocations();
+    if (isTimestampEvent) {
+        return queryStatusKernelTimestamp();
+    }
+    memcpy_s(static_cast<void *>(&queryVal), sizeof(uint32_t), static_cast<void *>(hostAddr), sizeof(uint32_t));
+    retVal = (queryVal == Event::STATE_CLEARED) ? ZE_RESULT_NOT_READY : ZE_RESULT_SUCCESS;
+
+    if (retVal == ZE_RESULT_NOT_READY) {
+        return retVal;
+    }
+
+    if (updateTaskCountEnabled) {
+        this->csr->flushTagUpdate();
+        updateTaskCountEnabled = false;
+    }
+
+    return retVal;
+}
+
+template <typename TagSizeT>
+ze_result_t EventImp<TagSizeT>::hostEventSetValueTimestamps(TagSizeT eventVal) {
+
+    auto baseAddr = reinterpret_cast<uint64_t>(hostAddress);
+    auto signalScopeFlag = this->signalScope;
+
+    auto eventTsSetFunc = [&eventVal, &signalScopeFlag](auto tsAddr) {
+        auto tsptr = reinterpret_cast<void *>(tsAddr);
+
+        memcpy_s(tsptr, sizeof(TagSizeT), static_cast<void *>(&eventVal), sizeof(TagSizeT));
+        if (!signalScopeFlag) {
+            NEO::CpuIntrinsics::clFlush(tsptr);
+        }
+    };
+    for (uint32_t i = 0; i < kernelCount; i++) {
+        uint32_t packetsToSet = kernelTimestampsData[i].getPacketsUsed();
+        for (uint32_t i = 0; i < packetsToSet; i++) {
+            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();
+        }
+    }
+    assignTimestampData(hostAddress);
+
+    return ZE_RESULT_SUCCESS;
+}
+
+template <typename TagSizeT>
+ze_result_t EventImp<TagSizeT>::hostEventSetValue(uint32_t eventVal) {
+    if (isTimestampEvent) {
+        return hostEventSetValueTimestamps(static_cast<TagSizeT>(eventVal));
+    }
+
+    auto hostAddr = static_cast<uint64_t *>(hostAddress);
+    UNRECOVERABLE_IF(hostAddr == nullptr);
+    memcpy_s(static_cast<void *>(hostAddr), sizeof(uint32_t), static_cast<void *>(&eventVal), sizeof(uint32_t));
+
+    if (updateTaskCountEnabled) {
+        this->csr->flushTagUpdate();
+        updateTaskCountEnabled = false;
+    }
+
+    NEO::CpuIntrinsics::clFlush(hostAddr);
+
+    return ZE_RESULT_SUCCESS;
+}
+
+template <typename TagSizeT>
+ze_result_t EventImp<TagSizeT>::hostSignal() {
+    return hostEventSetValue(Event::STATE_SIGNALED);
+}
+
+template <typename TagSizeT>
+ze_result_t EventImp<TagSizeT>::hostSynchronize(uint64_t timeout) {
+    std::chrono::high_resolution_clock::time_point time1, time2;
+    uint64_t timeDiff = 0;
+
+    ze_result_t ret = ZE_RESULT_NOT_READY;
+
+    if (this->csr->getType() == NEO::CommandStreamReceiverType::CSR_AUB) {
+        return ZE_RESULT_SUCCESS;
+    }
+
+    if (timeout == 0) {
+        return queryStatus();
+    }
+
+    time1 = std::chrono::high_resolution_clock::now();
+    while (true) {
+        ret = queryStatus();
+        if (ret == ZE_RESULT_SUCCESS) {
+            return ret;
+        }
+
+        NEO::WaitUtils::waitFunction(nullptr, 0u);
+
+        if (timeout == std::numeric_limits<uint32_t>::max()) {
+            continue;
+        }
+
+        time2 = std::chrono::high_resolution_clock::now();
+        timeDiff = std::chrono::duration_cast<std::chrono::nanoseconds>(time2 - time1).count();
+
+        if (timeDiff >= timeout) {
+            break;
+        }
+    }
+
+    return ret;
+}
+
+template <typename TagSizeT>
+ze_result_t EventImp<TagSizeT>::reset() {
+    if (isTimestampEvent) {
+        kernelCount = EventPacketsCount::maxKernelSplit;
+        for (uint32_t i = 0; i < kernelCount; i++) {
+            kernelTimestampsData[i].setPacketsUsed(NEO::TimestampPacketSizeControl::preferredPacketCount);
+        }
+        hostEventSetValue(Event::STATE_INITIAL);
+        resetPackets();
+        return ZE_RESULT_SUCCESS;
+    } else {
+        return hostEventSetValue(Event::STATE_INITIAL);
+    }
+}
+
+template <typename TagSizeT>
+ze_result_t EventImp<TagSizeT>::queryKernelTimestamp(ze_kernel_timestamp_result_t *dstptr) {
+
+    ze_kernel_timestamp_result_t &result = *dstptr;
+
+    if (queryStatus() != ZE_RESULT_SUCCESS) {
+        return ZE_RESULT_NOT_READY;
+    }
+
+    assignTimestampData(hostAddress);
+    calculateProfilingData();
+
+    auto eventTsSetFunc = [&](uint64_t &timestampFieldToCopy, uint64_t &timestampFieldForWriting) {
+        memcpy_s(&(timestampFieldForWriting), sizeof(uint64_t), static_cast<void *>(&timestampFieldToCopy), sizeof(uint64_t));
+    };
+
+    if (!NEO::HwHelper::get(device->getHwInfo().platform.eRenderCoreFamily).useOnlyGlobalTimestamps()) {
+        eventTsSetFunc(contextStartTS, result.context.kernelStart);
+        eventTsSetFunc(globalStartTS, result.global.kernelStart);
+        eventTsSetFunc(contextEndTS, result.context.kernelEnd);
+        eventTsSetFunc(globalEndTS, result.global.kernelEnd);
+    } else {
+        eventTsSetFunc(globalStartTS, result.context.kernelStart);
+        eventTsSetFunc(globalStartTS, result.global.kernelStart);
+        eventTsSetFunc(globalEndTS, result.context.kernelEnd);
+        eventTsSetFunc(globalEndTS, result.global.kernelEnd);
+    }
+
+    return ZE_RESULT_SUCCESS;
+}
+
+template <typename TagSizeT>
+void EventImp<TagSizeT>::resetPackets() {
+    for (uint32_t i = 0; i < kernelCount; i++) {
+        kernelTimestampsData[i].setPacketsUsed(1);
+    }
+    kernelCount = 1;
+}
+
+template <typename TagSizeT>
+uint32_t EventImp<TagSizeT>::getPacketsInUse() {
+    if (isTimestampEvent) {
+        uint32_t packetsInUse = 0;
+        for (uint32_t i = 0; i < kernelCount; i++) {
+            packetsInUse += kernelTimestampsData[i].getPacketsUsed();
+        };
+        return packetsInUse;
+    } else {
+        return 1;
+    }
+}
+
+template <typename TagSizeT>
+void EventImp<TagSizeT>::setPacketsInUse(uint32_t value) {
+    kernelTimestampsData[getCurrKernelDataIndex()].setPacketsUsed(value);
+};
+
+template <typename TagSizeT>
+uint64_t EventImp<TagSizeT>::getPacketAddress(Device *device) {
+    uint64_t address = getGpuAddress(device);
+    if (isTimestampEvent && kernelCount > 1) {
+        for (uint32_t i = 0; i < kernelCount - 1; i++) {
+            address += kernelTimestampsData[i].getPacketsUsed() *
+                       NEO::TimestampPackets<TagSizeT>::getSinglePacketSize();
+        }
+    }
+    return address;
+}
+
+} // namespace L0
diff --git a/level_zero/core/test/unit_tests/fixtures/cmdlist_fixture.h b/level_zero/core/test/unit_tests/fixtures/cmdlist_fixture.h
index 48c19a88fc..f592d55d93 100644
--- a/level_zero/core/test/unit_tests/fixtures/cmdlist_fixture.h
+++ b/level_zero/core/test/unit_tests/fixtures/cmdlist_fixture.h
@@ -32,7 +32,7 @@ class CommandListFixture : public DeviceFixture {
         eventDesc.signal = 0;
 
         eventPool = std::unique_ptr<EventPool>(EventPool::create(driverHandle.get(), context, 0, nullptr, &eventPoolDesc));
-        event = std::unique_ptr<Event>(Event::create(eventPool.get(), &eventDesc, device));
+        event = std::unique_ptr<Event>(Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     }
 
     void TearDown() override {
diff --git a/level_zero/core/test/unit_tests/gen12lp/test_events_gen12lp.cpp b/level_zero/core/test/unit_tests/gen12lp/test_events_gen12lp.cpp
index 4cc8bbea23..9d165c4c4b 100644
--- a/level_zero/core/test/unit_tests/gen12lp/test_events_gen12lp.cpp
+++ b/level_zero/core/test/unit_tests/gen12lp/test_events_gen12lp.cpp
@@ -34,7 +34,7 @@ struct TimestampEvent : public Test<DeviceFixture> {
 
         eventPool = std::unique_ptr<L0::EventPool>(L0::EventPool::create(driverHandle.get(), context, 0, nullptr, &eventPoolDesc));
         ASSERT_NE(nullptr, eventPool);
-        event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+        event = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
         ASSERT_NE(nullptr, event);
     }
 
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 199bab45b5..2e6b40b9e9 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
@@ -978,6 +978,11 @@ class MockEvent : public ::L0::Event {
         return ZE_RESULT_SUCCESS;
     };
 
+    uint32_t getPacketsInUse() override { return 1; }
+    void resetPackets() override{};
+    void setPacketsInUse(uint32_t value) override{};
+    uint64_t getPacketAddress(L0::Device *) override { return 0; }
+
     std::unique_ptr<NEO::GraphicsAllocation> mockAllocation;
 };
 
@@ -1636,8 +1641,8 @@ HWTEST_F(CommandListCreate, givenSyncCmdQueueAndCopyOnlyImmediateCommandListWhen
     ze_event_desc_t eventDesc = {};
     eventDesc.wait = ZE_EVENT_SCOPE_FLAG_HOST;
     auto eventPool = std::unique_ptr<L0::EventPool>(L0::EventPool::create(driverHandle.get(), context, 0, nullptr, &eventPoolDesc));
-    auto event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
-    auto event2 = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
+    auto event2 = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     ze_event_handle_t events[] = {event->toHandle(), event2->toHandle()};
 
     auto used = commandContainer.getCommandStream()->getUsed();
@@ -1665,7 +1670,7 @@ HWTEST2_F(CommandListCreate, givenCopyCommandListWhenProfilingBeforeCommandForCo
     ze_event_desc_t eventDesc = {};
     eventDesc.index = 0;
     auto eventPool = std::unique_ptr<L0::EventPool>(L0::EventPool::create(driverHandle.get(), context, 0, nullptr, &eventPoolDesc));
-    auto event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
 
     auto baseAddr = event->getGpuAddress(device);
     auto contextOffset = NEO::TimestampPackets<uint32_t>::getContextStartOffset();
@@ -1701,7 +1706,7 @@ HWTEST2_F(CommandListCreate, givenCopyCommandListWhenProfilingAfterCommandForCop
     ze_event_desc_t eventDesc = {};
     eventDesc.index = 0;
     auto eventPool = std::unique_ptr<L0::EventPool>(L0::EventPool::create(driverHandle.get(), context, 0, nullptr, &eventPoolDesc));
-    auto event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
 
     commandList->appendEventForProfilingCopyCommand(event->toHandle(), false);
 
diff --git a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_2.cpp b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_2.cpp
index d14ded6975..2e7cff83c1 100644
--- a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_2.cpp
+++ b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_2.cpp
@@ -479,10 +479,10 @@ HWTEST2_F(CommandListCreate, givenCommandListWhenMemoryCopyWithSignalEventsThenS
     ze_event_desc_t eventDesc = {};
     eventDesc.index = 0;
     eventDesc.wait = ZE_EVENT_SCOPE_FLAG_HOST;
-    auto event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     events.push_back(event.get());
     eventDesc.index = 1;
-    auto event1 = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event1 = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     events.push_back(event1.get());
 
     result = commandList->appendMemoryCopy(dstPtr, srcPtr, 0x1001, nullptr, 2u, events.data());
@@ -522,7 +522,7 @@ HWTEST2_F(CommandListCreate, givenCommandListWhenMemoryCopyWithSignalEventScopeS
     ze_event_desc_t eventDesc = {};
     eventDesc.index = 0;
     eventDesc.signal = ZE_EVENT_SCOPE_FLAG_DEVICE;
-    auto event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
 
     result = commandList->appendMemoryCopy(dstPtr, srcPtr, 0x1001, event.get(), 0u, nullptr);
     EXPECT_EQ(ZE_RESULT_SUCCESS, result);
@@ -567,7 +567,7 @@ HWTEST2_F(CommandListCreate, givenCommandListWhenMemoryCopyWithSignalEventScopeS
 
     ze_event_desc_t eventDesc = {};
     eventDesc.index = 0;
-    auto event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
 
     result = commandList->appendMemoryCopy(dstPtr, srcPtr, 0x1001, event.get(), 0u, nullptr);
     EXPECT_EQ(ZE_RESULT_SUCCESS, result);
@@ -1088,7 +1088,7 @@ HWTEST2_F(CommandListCreate, givenCopyCommandListWhenTimestampPassedToMemoryCopy
     eventDesc.wait = 0;
 
     auto eventPool = std::unique_ptr<L0::EventPool>(L0::EventPool::create(driverHandle.get(), context, 0, nullptr, &eventPoolDesc));
-    auto event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
 
     commandList.appendMemoryCopy(dstPtr, srcPtr, 0x100, event->toHandle(), 0, nullptr);
     EXPECT_GT(commandList.appendMemoryCopyBlitCalledTimes, 1u);
@@ -1175,7 +1175,7 @@ HWTEST2_F(CommandListCreate, givenCommandListWhenTimestampPassedToMemoryCopyThen
     eventDesc.index = 0;
 
     auto eventPool = std::unique_ptr<L0::EventPool>(L0::EventPool::create(driverHandle.get(), context, 0, nullptr, &eventPoolDesc));
-    auto event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
 
     commandList.appendMemoryCopy(dstPtr, srcPtr, 0x100, event->toHandle(), 0, nullptr);
     EXPECT_GT(commandList.appendMemoryCopyKernelWithGACalledTimes, 0u);
diff --git a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_3.cpp b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_3.cpp
index a2c2c0c580..6da9748e69 100644
--- a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_3.cpp
+++ b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_3.cpp
@@ -259,10 +259,10 @@ HWTEST2_F(CommandListCreate, givenCommandListWhenMemoryCopyRegionHavingHostMemor
     ze_event_desc_t eventDesc = {};
     eventDesc.index = 0;
     eventDesc.wait = ZE_EVENT_SCOPE_FLAG_HOST;
-    auto event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     events.push_back(event.get());
     eventDesc.index = 1;
-    auto event1 = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event1 = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     events.push_back(event1.get());
 
     ze_copy_region_t sr = {0U, 0U, 0U, width, height, 0U};
@@ -327,10 +327,10 @@ HWTEST2_F(CommandListCreate, givenCommandListWhenMemoryCopyRegionHavingDeviceMem
     ze_event_desc_t eventDesc = {};
     eventDesc.index = 0;
     eventDesc.wait = ZE_EVENT_SCOPE_FLAG_HOST;
-    auto event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     events.push_back(event.get());
     eventDesc.index = 1;
-    auto event1 = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event1 = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     events.push_back(event1.get());
 
     ze_copy_region_t sr = {0U, 0U, 0U, width, height, 0U};
@@ -389,10 +389,10 @@ HWTEST2_F(CommandListCreate, givenCommandListWhenMemoryFillHavingDeviceMemoryWit
     ze_event_desc_t eventDesc = {};
     eventDesc.index = 0;
     eventDesc.wait = ZE_EVENT_SCOPE_FLAG_HOST;
-    auto event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     events.push_back(event.get());
     eventDesc.index = 1;
-    auto event1 = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event1 = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     events.push_back(event1.get());
 
     int one = 1;
@@ -450,10 +450,10 @@ HWTEST2_F(CommandListCreate, givenCommandListWhenMemoryFillHavingSharedMemoryWit
     ze_event_desc_t eventDesc = {};
     eventDesc.index = 0;
     eventDesc.wait = ZE_EVENT_SCOPE_FLAG_HOST;
-    auto event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     events.push_back(event.get());
     eventDesc.index = 1;
-    auto event1 = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event1 = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     events.push_back(event1.get());
 
     int one = 1;
@@ -514,10 +514,10 @@ HWTEST2_F(CommandListCreate, givenCommandListWhenMemoryFillHavingHostMemoryWithS
     eventDesc.index = 0;
     eventDesc.wait = ZE_EVENT_SCOPE_FLAG_HOST;
     eventDesc.signal = ZE_EVENT_SCOPE_FLAG_HOST;
-    auto event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     events.push_back(event.get());
     eventDesc.index = 1;
-    auto event1 = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event1 = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     events.push_back(event1.get());
 
     int one = 1;
@@ -576,10 +576,10 @@ HWTEST2_F(CommandListCreate, givenCommandListWhenMemoryFillHavingEventsWithDevic
     eventDesc.index = 0;
     eventDesc.wait = ZE_EVENT_SCOPE_FLAG_DEVICE;
     eventDesc.signal = ZE_EVENT_SCOPE_FLAG_DEVICE;
-    auto event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     events.push_back(event.get());
     eventDesc.index = 1;
-    auto event1 = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event1 = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     events.push_back(event1.get());
 
     int one = 1;
@@ -631,10 +631,10 @@ HWTEST2_F(CommandListCreate, givenCommandListWhenMemoryFillHavingEventsWithDevic
     eventDesc.index = 0;
     eventDesc.wait = 0;
     eventDesc.signal = 0;
-    auto event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     events.push_back(event.get());
     eventDesc.index = 1;
-    auto event1 = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event1 = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     events.push_back(event1.get());
 
     int one = 1;
@@ -680,10 +680,10 @@ HWTEST2_F(CommandListCreate, givenCommandListWhenMemoryCopyRegionWithSignalAndWa
     ze_event_desc_t eventDesc = {};
     eventDesc.index = 0;
     eventDesc.wait = ZE_EVENT_SCOPE_FLAG_HOST;
-    auto event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     events.push_back(event.get());
     eventDesc.index = 1;
-    auto event1 = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event1 = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     events.push_back(event1.get());
 
     ze_copy_region_t sr = {0U, 0U, 0U, width, height, 0U};
@@ -713,10 +713,10 @@ HWTEST2_F(CommandListCreate, givenCommandListWhenMemoryCopyRegionWithSignalAndIn
     ze_event_desc_t eventDesc = {};
     eventDesc.index = 0;
     eventDesc.wait = ZE_EVENT_SCOPE_FLAG_HOST;
-    auto event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     events.push_back(event.get());
     eventDesc.index = 1;
-    auto event1 = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event1 = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     events.push_back(event1.get());
 
     ze_copy_region_t sr = {0U, 0U, 0U, width, height, 0U};
@@ -752,10 +752,10 @@ HWTEST2_F(CommandListCreate, givenImmediateCommandListWhenMemoryCopyRegionWithSi
     ze_event_desc_t eventDesc = {};
     eventDesc.index = 0;
     eventDesc.wait = ZE_EVENT_SCOPE_FLAG_HOST;
-    auto event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     events.push_back(event.get());
     eventDesc.index = 1;
-    auto event1 = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event1 = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     events.push_back(event1.get());
 
     EXPECT_CALL(cmdQueue, executeCommandLists).Times(1).WillRepeatedly(::testing::Return(ZE_RESULT_SUCCESS));
@@ -795,10 +795,10 @@ HWTEST2_F(CommandListCreate, givenImmediateCommandListWhenMemoryCopyRegionWithSi
     ze_event_desc_t eventDesc = {};
     eventDesc.index = 0;
     eventDesc.wait = ZE_EVENT_SCOPE_FLAG_HOST;
-    auto event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     events.push_back(event.get());
     eventDesc.index = 1;
-    auto event1 = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event1 = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     events.push_back(event1.get());
 
     EXPECT_CALL(cmdQueue, executeCommandLists).Times(1).WillRepeatedly(::testing::Return(ZE_RESULT_SUCCESS));
@@ -838,10 +838,10 @@ HWTEST2_F(CommandListCreate, givenImmediateCommandListWhenMemoryCopyRegionWithSi
     ze_event_desc_t eventDesc = {};
     eventDesc.index = 0;
     eventDesc.wait = ZE_EVENT_SCOPE_FLAG_HOST;
-    auto event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     events.push_back(event.get());
     eventDesc.index = 1;
-    auto event1 = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event1 = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     events.push_back(event1.get());
 
     ze_copy_region_t sr = {0U, 0U, 0U, width, height, 0U};
@@ -998,8 +998,8 @@ HWTEST_F(CommandListCreate, givenAsyncCmdQueueAndCopyOnlyImmediateCommandListWhe
     ze_event_desc_t eventDesc = {};
     eventDesc.wait = ZE_EVENT_SCOPE_FLAG_HOST;
     auto eventPool = std::unique_ptr<L0::EventPool>(L0::EventPool::create(driverHandle.get(), context, 0, nullptr, &eventPoolDesc));
-    auto event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
-    auto event2 = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
+    auto event2 = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     ze_event_handle_t events[] = {event->toHandle(), event2->toHandle()};
 
     auto used = commandContainer.getCommandStream()->getUsed();
@@ -1045,9 +1045,9 @@ TEST_F(CommandListCreate, givenQueueDescriptionwhenCreatingImmediateCommandListF
             eventDesc.signal = ZE_EVENT_SCOPE_FLAG_HOST;
             eventDesc.wait = ZE_EVENT_SCOPE_FLAG_HOST;
             auto eventPool = std::unique_ptr<L0::EventPool>(L0::EventPool::create(driverHandle.get(), context, 0, nullptr, &eventPoolDesc));
-            auto event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
-            auto event1 = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
-            auto event2 = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+            auto event = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
+            auto event1 = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
+            auto event2 = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
             ze_event_handle_t events[] = {event1->toHandle(), event2->toHandle()};
 
             commandList->appendBarrier(nullptr, 0, nullptr);
@@ -1224,10 +1224,10 @@ HWTEST2_F(HostPointerManagerCommandListTest, givenCommandListWhenMemoryFillWithS
     ze_event_desc_t eventDesc = {};
     eventDesc.index = 0;
     eventDesc.wait = ZE_EVENT_SCOPE_FLAG_HOST;
-    auto event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     events.push_back(event.get());
     eventDesc.index = 1;
-    auto event1 = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event1 = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     events.push_back(event1.get());
 
     result = commandList->appendMemoryFill(heapPointer, reinterpret_cast<void *>(&one), sizeof(one), size,
@@ -1268,10 +1268,10 @@ HWTEST2_F(HostPointerManagerCommandListTest, givenCommandListWhenMemoryFillWithS
     ze_event_desc_t eventDesc = {};
     eventDesc.index = 0;
     eventDesc.wait = ZE_EVENT_SCOPE_FLAG_HOST;
-    auto event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     events.push_back(event.get());
     eventDesc.index = 1;
-    auto event1 = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event1 = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     events.push_back(event1.get());
 
     result = commandList->appendMemoryFill(heapPointer, reinterpret_cast<void *>(&one), sizeof(one), size,
@@ -1314,10 +1314,10 @@ HWTEST2_F(HostPointerManagerCommandListTest, givenCommandListWhenMemoryFillWithS
     ze_event_desc_t eventDesc = {};
     eventDesc.index = 0;
     eventDesc.wait = ZE_EVENT_SCOPE_FLAG_HOST;
-    auto event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     events.push_back(event.get());
     eventDesc.index = 1;
-    auto event1 = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event1 = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     events.push_back(event1.get());
 
     result = commandList->appendMemoryFill(heapPointer, reinterpret_cast<void *>(&one), sizeof(one), size,
@@ -1350,10 +1350,10 @@ HWTEST2_F(HostPointerManagerCommandListTest, givenCommandListWhenMemoryFillWithS
     ze_event_desc_t eventDesc = {};
     eventDesc.index = 0;
     eventDesc.wait = ZE_EVENT_SCOPE_FLAG_HOST;
-    auto event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     events.push_back(event.get());
     eventDesc.index = 1;
-    auto event1 = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event1 = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     events.push_back(event1.get());
 
     result = commandList->appendMemoryFill(heapPointer, reinterpret_cast<void *>(&one), sizeof(one), size,
@@ -1397,10 +1397,10 @@ HWTEST2_F(HostPointerManagerCommandListTest, givenImmediateCommandListWhenMemory
     ze_event_desc_t eventDesc = {};
     eventDesc.index = 0;
     eventDesc.wait = ZE_EVENT_SCOPE_FLAG_HOST;
-    auto event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     events.push_back(event.get());
     eventDesc.index = 1;
-    auto event1 = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event1 = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     events.push_back(event1.get());
 
     EXPECT_CALL(cmdQueue, executeCommandLists).Times(1).WillRepeatedly(::testing::Return(ZE_RESULT_SUCCESS));
@@ -1441,10 +1441,10 @@ HWTEST2_F(HostPointerManagerCommandListTest, givenImmediateCommandListWhenMemory
     ze_event_desc_t eventDesc = {};
     eventDesc.index = 0;
     eventDesc.wait = ZE_EVENT_SCOPE_FLAG_HOST;
-    auto event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     events.push_back(event.get());
     eventDesc.index = 1;
-    auto event1 = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event1 = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     events.push_back(event1.get());
 
     EXPECT_CALL(cmdQueue, executeCommandLists).Times(1).WillRepeatedly(::testing::Return(ZE_RESULT_SUCCESS));
@@ -1488,10 +1488,10 @@ HWTEST2_F(HostPointerManagerCommandListTest, givenImmediateCommandListWhenMemory
     ze_event_desc_t eventDesc = {};
     eventDesc.index = 0;
     eventDesc.wait = ZE_EVENT_SCOPE_FLAG_HOST;
-    auto event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     events.push_back(event.get());
     eventDesc.index = 1;
-    auto event1 = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event1 = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     events.push_back(event1.get());
 
     result = commandList->appendMemoryFill(heapPointer, reinterpret_cast<void *>(&one), sizeof(one), size,
diff --git a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_event_reset.cpp b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_event_reset.cpp
index e035a33bb0..5239a211db 100644
--- a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_event_reset.cpp
+++ b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_event_reset.cpp
@@ -132,7 +132,7 @@ HWTEST2_F(CommandListAppendEventReset, givenTimestampEventUsedInResetThenPipeCon
     ze_event_desc_t eventDesc = {};
     eventDesc.index = 0;
     auto eventPool = std::unique_ptr<L0::EventPool>(L0::EventPool::create(driverHandle.get(), context, 0, nullptr, &eventPoolDesc));
-    auto event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
 
     event->setPacketsInUse(16u);
     commandList->appendEventReset(event->toHandle());
@@ -178,7 +178,7 @@ HWTEST2_F(CommandListAppendEventReset, givenEventWithHostScopeUsedInResetThenPip
     eventDesc.signal = ZE_EVENT_SCOPE_FLAG_HOST;
 
     auto eventPool = std::unique_ptr<L0::EventPool>(L0::EventPool::create(driverHandle.get(), context, 0, nullptr, &eventPoolDesc));
-    auto event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
 
     commandList->appendEventReset(event->toHandle());
     auto gpuAddress = event->getGpuAddress(device);
diff --git a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_launch_kernel.cpp b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_launch_kernel.cpp
index 0e1345168e..7e3bbce131 100644
--- a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_launch_kernel.cpp
+++ b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_launch_kernel.cpp
@@ -292,7 +292,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, CommandListAppendLaunchKernel, givenEventsWhenAppend
     eventDesc.index = 0;
 
     auto eventPool = std::unique_ptr<EventPool>(EventPool::create(driverHandle.get(), context, 0, nullptr, &eventPoolDesc));
-    auto event = std::unique_ptr<Event>(Event::create(eventPool.get(), &eventDesc, device));
+    auto event = std::unique_ptr<Event>(Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
 
     ze_group_count_t groupCount{1, 1, 1};
     auto result = commandList->appendLaunchKernel(
@@ -354,7 +354,7 @@ HWTEST2_F(CommandListAppendLaunchKernel, givenTimestampEventsWhenAppendingKernel
     eventDesc.signal = ZE_EVENT_SCOPE_FLAG_DEVICE;
 
     auto eventPool = std::unique_ptr<EventPool>(EventPool::create(driverHandle.get(), context, 0, nullptr, &eventPoolDesc));
-    auto event = std::unique_ptr<Event>(Event::create(eventPool.get(), &eventDesc, device));
+    auto event = std::unique_ptr<Event>(Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
 
     ze_group_count_t groupCount{1, 1, 1};
     auto result = commandList->appendLaunchKernel(
@@ -447,7 +447,7 @@ HWTEST2_F(CommandListAppendLaunchKernel, givenKernelLaunchWithTSEventAndScopeFla
         ZE_EVENT_SCOPE_FLAG_HOST};
 
     auto eventPool = std::unique_ptr<EventPool>(EventPool::create(driverHandle.get(), context, 0, nullptr, &eventPoolDesc));
-    auto event = std::unique_ptr<Event>(Event::create(eventPool.get(), &eventDesc, device));
+    auto event = std::unique_ptr<Event>(Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
 
     ze_group_count_t groupCount{1, 1, 1};
     auto result = commandList->appendLaunchKernel(
@@ -580,7 +580,7 @@ HWTEST2_F(CommandListAppendLaunchKernel, givenCommandListWhenAppendLaunchKernelS
         ZE_EVENT_SCOPE_FLAG_HOST};
 
     auto eventPool = std::unique_ptr<EventPool>(EventPool::create(driverHandle.get(), context, 0, nullptr, &eventPoolDesc));
-    auto event = std::unique_ptr<Event>(Event::create(eventPool.get(), &eventDesc, device));
+    auto event = std::unique_ptr<Event>(Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     EXPECT_EQ(1u, event->getPacketsInUse());
     ze_group_count_t groupCount{1, 1, 1};
     for (uint32_t i = 0; i < NEO::TimestampPacketSizeControl::preferredPacketCount + 4; i++) {
@@ -948,7 +948,7 @@ HWTEST_F(CommandListAppendLaunchKernel, givenSingleValidWaitEventsThenAddSemapho
     eventDesc.index = 0;
 
     std::unique_ptr<EventPool> eventPool(EventPool::create(driverHandle.get(), context, 0, nullptr, &eventPoolDesc));
-    std::unique_ptr<Event> event(Event::create(eventPool.get(), &eventDesc, device));
+    std::unique_ptr<Event> event(Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     ze_event_handle_t hEventHandle = event->toHandle();
 
     ze_group_count_t groupCount{1, 1, 1};
@@ -994,8 +994,8 @@ HWTEST_F(CommandListAppendLaunchKernel, givenMultipleValidWaitEventsThenAddSemap
     eventDesc2.index = 1;
 
     std::unique_ptr<EventPool> eventPool(EventPool::create(driverHandle.get(), context, 0, nullptr, &eventPoolDesc));
-    std::unique_ptr<Event> event1(Event::create(eventPool.get(), &eventDesc1, device));
-    std::unique_ptr<Event> event2(Event::create(eventPool.get(), &eventDesc2, device));
+    std::unique_ptr<Event> event1(Event::create<uint32_t>(eventPool.get(), &eventDesc1, device));
+    std::unique_ptr<Event> event2(Event::create<uint32_t>(eventPool.get(), &eventDesc2, device));
     ze_event_handle_t hEventHandle1 = event1->toHandle();
     ze_event_handle_t hEventHandle2 = event2->toHandle();
 
diff --git a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_signal_event.cpp b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_signal_event.cpp
index b52c320aab..58293b4d6c 100644
--- a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_signal_event.cpp
+++ b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_signal_event.cpp
@@ -110,7 +110,7 @@ HWTEST_F(CommandListAppendSignalEvent, givenEventWithScopeFlagDeviceWhenAppendin
     eventDesc.signal = ZE_EVENT_SCOPE_FLAG_DEVICE;
 
     auto eventPoolHostVisible = std::unique_ptr<EventPool>(EventPool::create(driverHandle.get(), context, 0, nullptr, &eventPoolDesc));
-    auto eventHostVisible = std::unique_ptr<Event>(Event::create(eventPoolHostVisible.get(), &eventDesc, device));
+    auto eventHostVisible = std::unique_ptr<Event>(Event::create<uint32_t>(eventPoolHostVisible.get(), &eventDesc, device));
 
     auto usedSpaceBefore = commandList->commandContainer.getCommandStream()->getUsed();
     auto result = commandList->appendSignalEvent(eventHostVisible->toHandle());
@@ -198,7 +198,7 @@ HWTEST2_F(CommandListAppendSignalEvent, givenTimestampEventUsedInSignalThenPipeC
     ze_event_desc_t eventDesc = {};
     eventDesc.index = 0;
     auto eventPool = std::unique_ptr<L0::EventPool>(L0::EventPool::create(driverHandle.get(), context, 0, nullptr, &eventPoolDesc));
-    auto event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
 
     commandList->appendSignalEvent(event->toHandle());
     auto contextOffset = NEO::TimestampPackets<uint32_t>::getContextEndOffset();
diff --git a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_wait_on_events.cpp b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_wait_on_events.cpp
index 3816d8e47f..7eea0836d8 100644
--- a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_wait_on_events.cpp
+++ b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_wait_on_events.cpp
@@ -112,7 +112,7 @@ HWTEST_F(CommandListAppendWaitOnEvent, givenEventWithWaitScopeFlagDeviceWhenAppe
         0,
         ZE_EVENT_SCOPE_FLAG_DEVICE};
 
-    auto event = std::unique_ptr<Event>(Event::create(eventPool.get(), &eventDesc, device));
+    auto event = std::unique_ptr<Event>(Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     ze_event_handle_t hEventHandle = event->toHandle();
 
     auto result = commandList->appendWaitOnEvents(1, &hEventHandle);
@@ -147,7 +147,7 @@ HWTEST_F(CommandListAppendWaitOnEvent, WhenAppendingWaitOnTimestampEventWithThre
     ze_event_desc_t eventDesc = {};
     eventDesc.index = 0;
     std::unique_ptr<L0::EventPool> eventPool(EventPool::create(driverHandle.get(), context, 0, nullptr, &eventPoolDesc));
-    auto event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
 
     event->setPacketsInUse(3u);
     ze_event_handle_t hEventHandle = event->toHandle();
@@ -194,7 +194,7 @@ HWTEST_F(CommandListAppendWaitOnEvent, WhenAppendingWaitOnTimestampEventWithThre
     ze_event_desc_t eventDesc = {};
     eventDesc.index = 0;
     std::unique_ptr<L0::EventPool> eventPool(EventPool::create(driverHandle.get(), context, 0, nullptr, &eventPoolDesc));
-    auto event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
 
     event->setPacketsInUse(3u);
     event->kernelCount = 2;
diff --git a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_blit.cpp b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_blit.cpp
index fcdad32d98..8d298616fe 100644
--- a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_blit.cpp
+++ b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_blit.cpp
@@ -193,7 +193,7 @@ HWTEST2_F(AppendMemoryCopy, givenCopyCommandListWhenTimestampPassedToMemoryCopyR
     ze_event_desc_t eventDesc = {};
     eventDesc.index = 0;
     auto eventPool = std::unique_ptr<L0::EventPool>(L0::EventPool::create(driverHandle.get(), context, 0, nullptr, &eventPoolDesc));
-    auto event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
 
     ze_copy_region_t srcRegion = {4, 4, 4, 2, 2, 2};
     ze_copy_region_t dstRegion = {4, 4, 4, 2, 2, 2};
@@ -252,7 +252,7 @@ HWTEST2_F(AppendMemoryCopy, givenCopyCommandListWhenTimestampPassedToImageCopyBl
     ze_event_desc_t eventDesc = {};
     eventDesc.index = 0;
     auto eventPool = std::unique_ptr<L0::EventPool>(L0::EventPool::create(driverHandle.get(), context, 0, nullptr, &eventPoolDesc));
-    auto event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
 
     NEO::MockGraphicsAllocation mockAllocationSrc(0, NEO::GraphicsAllocation::AllocationType::INTERNAL_HOST_MEMORY,
                                                   reinterpret_cast<void *>(0x1234), 0x1000, 0, sizeof(uint32_t),
diff --git a/level_zero/core/test/unit_tests/sources/event/test_event.cpp b/level_zero/core/test/unit_tests/sources/event/test_event.cpp
index eb34fa5fce..d219a09526 100644
--- a/level_zero/core/test/unit_tests/sources/event/test_event.cpp
+++ b/level_zero/core/test/unit_tests/sources/event/test_event.cpp
@@ -241,7 +241,7 @@ TEST_F(EventCreate, givenAnEventCreatedThenTheEventHasTheDeviceCommandStreamRece
     std::unique_ptr<L0::EventPool> eventPool(EventPool::create(driverHandle.get(), context, 0, nullptr, &eventPoolDesc));
     ASSERT_NE(nullptr, eventPool);
 
-    std::unique_ptr<L0::Event> event(Event::create(eventPool.get(), &eventDesc, device));
+    std::unique_ptr<L0::Event> event(Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     ASSERT_NE(nullptr, event);
     ASSERT_NE(nullptr, event.get()->csr);
     ASSERT_EQ(static_cast<DeviceImp *>(device)->neoDevice->getDefaultEngine().commandStreamReceiver, event.get()->csr);
@@ -258,7 +258,7 @@ TEST_F(EventCreate, givenEventWhenSignaledAndResetFromTheHostThenCorrectDataAndO
 
     auto eventPool = std::unique_ptr<L0::EventPool>(L0::EventPool::create(driverHandle.get(), context, 0, nullptr, &eventPoolDesc));
     ASSERT_NE(nullptr, eventPool);
-    auto event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    auto event = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     ASSERT_NE(nullptr, event);
 
     ze_result_t result = event->queryStatus();
@@ -317,7 +317,7 @@ class EventSynchronizeTest : public Test<DeviceFixture> {
 
         eventPool = std::unique_ptr<L0::EventPool>(L0::EventPool::create(driverHandle.get(), context, 0, nullptr, &eventPoolDesc));
         ASSERT_NE(nullptr, eventPool);
-        event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+        event = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
         ASSERT_NE(nullptr, event);
     }
 
@@ -386,7 +386,7 @@ HWTEST_F(EventAubCsrTest, givenCallToEventHostSynchronizeWithAubModeCsrReturnsSu
 
     eventPool = std::unique_ptr<L0::EventPool>(L0::EventPool::create(driverHandle.get(), context, 0, nullptr, &eventPoolDesc));
     ASSERT_NE(nullptr, eventPool);
-    event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    event = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     ASSERT_NE(nullptr, event);
 
     ze_result_t result = event->hostSynchronize(10);
@@ -430,7 +430,7 @@ class TimestampEventCreate : public Test<DeviceFixture> {
 
         eventPool = std::unique_ptr<L0::EventPool>(L0::EventPool::create(driverHandle.get(), context, 0, nullptr, &eventPoolDesc));
         ASSERT_NE(nullptr, eventPool);
-        event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+        event = std::unique_ptr<L0::EventImp<uint32_t>>(static_cast<L0::EventImp<uint32_t> *>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device)));
         ASSERT_NE(nullptr, event);
     }
 
@@ -439,7 +439,7 @@ class TimestampEventCreate : public Test<DeviceFixture> {
     }
 
     std::unique_ptr<L0::EventPool> eventPool;
-    std::unique_ptr<L0::Event> event;
+    std::unique_ptr<L0::EventImp<uint32_t>> event;
 };
 
 TEST_F(TimestampEventCreate, givenEventCreatedWithTimestampThenIsTimestampEventFlagSet) {
@@ -545,7 +545,7 @@ HWCMDTEST_EXCLUDE_ADDITIONAL_FAMILY(TimestampEventCreate, givenEventTimestampsWh
 HWCMDTEST_EXCLUDE_ADDITIONAL_FAMILY(TimestampEventCreate, givenEventTimestampsWhenQueryKernelTimestampThenCorrectDataAreSet, IGFX_DG1);
 
 TEST_F(TimestampEventCreate, givenEventWhenQueryKernelTimestampThenNotReadyReturned) {
-    struct MockEventQuery : public EventImp {
+    struct MockEventQuery : public EventImp<uint32_t> {
         MockEventQuery(L0::EventPool *eventPool, int index, L0::Device *device) : EventImp(eventPool, index, device) {}
 
         ze_result_t queryStatus() override {
@@ -790,7 +790,7 @@ class EventTests : public DeviceFixture,
 };
 
 TEST_F(EventTests, WhenQueryingStatusThenSuccessIsReturned) {
-    auto event = whitebox_cast(Event::create(eventPool, &eventDesc, device));
+    auto event = whitebox_cast(Event::create<uint32_t>(eventPool, &eventDesc, device));
     ASSERT_NE(event, nullptr);
 
     auto result = event->hostSignal();
@@ -802,7 +802,7 @@ TEST_F(EventTests, WhenQueryingStatusThenSuccessIsReturned) {
 }
 
 TEST_F(EventTests, GivenResetWhenQueryingStatusThenNotReadyIsReturned) {
-    auto event = whitebox_cast(Event::create(eventPool, &eventDesc, device));
+    auto event = whitebox_cast(Event::create<uint32_t>(eventPool, &eventDesc, device));
     ASSERT_NE(event, nullptr);
 
     auto result = event->hostSignal();
@@ -817,7 +817,7 @@ TEST_F(EventTests, GivenResetWhenQueryingStatusThenNotReadyIsReturned) {
 }
 
 TEST_F(EventTests, WhenDestroyingAnEventThenSuccessIsReturned) {
-    auto event = whitebox_cast(Event::create(eventPool, &eventDesc, device));
+    auto event = whitebox_cast(Event::create<uint32_t>(eventPool, &eventDesc, device));
     ASSERT_NE(event, nullptr);
 
     auto result = event->destroy();
@@ -833,10 +833,10 @@ TEST_F(EventTests, givenTwoEventsCreatedThenTheyHaveDifferentAddresses) {
     eventDesc1.index = 1;
     eventDesc.index = 1;
 
-    auto event0 = whitebox_cast(Event::create(eventPool, &eventDesc0, device));
+    auto event0 = whitebox_cast(Event::create<uint32_t>(eventPool, &eventDesc0, device));
     ASSERT_NE(event0, nullptr);
 
-    auto event1 = whitebox_cast(Event::create(eventPool, &eventDesc1, device));
+    auto event1 = whitebox_cast(Event::create<uint32_t>(eventPool, &eventDesc1, device));
     ASSERT_NE(event1, nullptr);
 
     EXPECT_NE(event0->hostAddress, event1->hostAddress);