performance: Cache timestamps on CPU

LukaszJobczyk · Compute-Runtime-Automation · commit 83637404bf37 · 2025-03-11T13:40:18.000+01:00
Signed-off-by: Lukasz Jobczyk &lt;lukasz.jobczyk@intel.com&gt;
diff --git a/shared/source/os_interface/linux/drm_memory_manager.cpp b/shared/source/os_interface/linux/drm_memory_manager.cpp
@@ -1980,7 +1980,7 @@ inline std::unique_ptr<Gmm> DrmMemoryManager::makeGmmIfSingleHandle(const Alloca
     gmmRequirements.allowLargePages = true;
     gmmRequirements.preferCompressed = allocationData.flags.preferCompressed;
 
-    if (productHelper.overrideAllocationCacheable(allocationData)) {
+    if (productHelper.overrideAllocationCpuCacheable(allocationData)) {
         gmmRequirements.overriderCacheable.enableOverride = true;
         gmmRequirements.overriderCacheable.value = true;
     }
diff --git a/shared/source/os_interface/product_helper.h b/shared/source/os_interface/product_helper.h
@@ -196,7 +196,7 @@ class ProductHelper {
     virtual uint32_t getMaxNumSamplers() const = 0;
     virtual uint32_t getCommandBuffersPreallocatedPerCommandQueue() const = 0;
     virtual uint32_t getInternalHeapsPreallocated() const = 0;
-    virtual bool overrideAllocationCacheable(const AllocationData &allocationData) const = 0;
+    virtual bool overrideAllocationCpuCacheable(const AllocationData &allocationData) const = 0;
     virtual bool is2MBLocalMemAlignmentEnabled() const = 0;
 
     virtual bool getFrontEndPropertyScratchSizeSupport() const = 0;
diff --git a/shared/source/os_interface/product_helper.inl b/shared/source/os_interface/product_helper.inl
@@ -219,7 +219,7 @@ uint64_t ProductHelperHw<gfxProduct>::getDeviceMemoryMaxBandWidthInBytesPerSecon
 }
 
 template <PRODUCT_FAMILY gfxProduct>
-bool ProductHelperHw<gfxProduct>::overrideAllocationCacheable(const AllocationData &allocationData) const {
+bool ProductHelperHw<gfxProduct>::overrideAllocationCpuCacheable(const AllocationData &allocationData) const {
     return false;
 }
 
diff --git a/shared/source/os_interface/product_helper_hw.h b/shared/source/os_interface/product_helper_hw.h
@@ -137,7 +137,7 @@ class ProductHelperHw : public ProductHelper {
     uint32_t getMaxNumSamplers() const override;
     uint32_t getCommandBuffersPreallocatedPerCommandQueue() const override;
     uint32_t getInternalHeapsPreallocated() const override;
-    bool overrideAllocationCacheable(const AllocationData &allocationData) const override;
+    bool overrideAllocationCpuCacheable(const AllocationData &allocationData) const override;
     bool is2MBLocalMemAlignmentEnabled() const override;
 
     bool getFrontEndPropertyScratchSizeSupport() const override;
diff --git a/shared/source/os_interface/windows/wddm_memory_manager.cpp b/shared/source/os_interface/windows/wddm_memory_manager.cpp
@@ -234,7 +234,7 @@ GraphicsAllocation *WddmMemoryManager::allocateGraphicsMemoryUsingKmdAndMapItToC
     GmmRequirements gmmRequirements{};
     gmmRequirements.allowLargePages = allowLargePages;
     gmmRequirements.preferCompressed = allocationData.flags.preferCompressed;
-    if (productHelper.overrideAllocationCacheable(allocationData)) {
+    if (productHelper.overrideAllocationCpuCacheable(allocationData)) {
         gmmRequirements.overriderCacheable.enableOverride = true;
         gmmRequirements.overriderCacheable.value = true;
     }
@@ -464,7 +464,7 @@ GraphicsAllocation *WddmMemoryManager::allocateGraphicsMemoryForNonSvmHostPtr(co
     GmmRequirements gmmRequirements{};
     gmmRequirements.allowLargePages = true;
     gmmRequirements.preferCompressed = false;
-    if (productHelper.overrideAllocationCacheable(allocationData)) {
+    if (productHelper.overrideAllocationCpuCacheable(allocationData)) {
         gmmRequirements.overriderCacheable.enableOverride = true;
         gmmRequirements.overriderCacheable.value = true;
     }
diff --git a/shared/source/xe2_hpg_core/lnl/os_agnostic_product_helper_lnl.inl b/shared/source/xe2_hpg_core/lnl/os_agnostic_product_helper_lnl.inl
@@ -12,8 +12,8 @@
 namespace NEO {
 
 template <>
-bool ProductHelperHw<gfxProduct>::overrideAllocationCacheable(const AllocationData &allocationData) const {
-    return allocationData.type == AllocationType::commandBuffer || this->overrideCacheableForDcFlushMitigation(allocationData.type);
+bool ProductHelperHw<gfxProduct>::overrideAllocationCpuCacheable(const AllocationData &allocationData) const {
+    return allocationData.type == AllocationType::commandBuffer || allocationData.type == AllocationType::timestampPacketTagBuffer || this->overrideCacheableForDcFlushMitigation(allocationData.type);
 }
 
 template <>
diff --git a/shared/source/xe3_core/ptl/os_agnostic_product_helper_ptl.inl b/shared/source/xe3_core/ptl/os_agnostic_product_helper_ptl.inl
@@ -10,8 +10,8 @@
 namespace NEO {
 
 template <>
-bool ProductHelperHw<gfxProduct>::overrideAllocationCacheable(const AllocationData &allocationData) const {
-    return allocationData.type == AllocationType::commandBuffer || this->overrideCacheableForDcFlushMitigation(allocationData.type);
+bool ProductHelperHw<gfxProduct>::overrideAllocationCpuCacheable(const AllocationData &allocationData) const {
+    return allocationData.type == AllocationType::commandBuffer || allocationData.type == AllocationType::timestampPacketTagBuffer || this->overrideCacheableForDcFlushMitigation(allocationData.type);
 }
 
 template <>
diff --git a/shared/source/xe_hpg_core/xe_lpg/os_agnostic_product_helper_xe_lpg.inl b/shared/source/xe_hpg_core/xe_lpg/os_agnostic_product_helper_xe_lpg.inl
@@ -73,7 +73,7 @@ bool ProductHelperHw<gfxProduct>::isDeviceUsmPoolAllocatorSupported() const {
 }
 
 template <>
-bool ProductHelperHw<gfxProduct>::overrideAllocationCacheable(const AllocationData &allocationData) const {
+bool ProductHelperHw<gfxProduct>::overrideAllocationCpuCacheable(const AllocationData &allocationData) const {
     return allocationData.type == AllocationType::commandBuffer;
 }
 
diff --git a/shared/test/common/mocks/mock_product_helper.h b/shared/test/common/mocks/mock_product_helper.h
@@ -17,7 +17,7 @@ struct MockProductHelper : ProductHelperHw<IGFX_UNKNOWN> {
     MockProductHelper() = default;
 
     ADDMETHOD_CONST_NOBASE(is48bResourceNeededForRayTracing, bool, true, ());
-    ADDMETHOD_CONST_NOBASE(overrideAllocationCacheable, bool, false, (const AllocationData &allocationData));
+    ADDMETHOD_CONST_NOBASE(overrideAllocationCpuCacheable, bool, false, (const AllocationData &allocationData));
     ADDMETHOD_NOBASE(configureHwInfoWddm, int, 0, (const HardwareInfo *inHwInfo, HardwareInfo *outHwInfo, const RootDeviceEnvironment &rootDeviceEnvironment));
     ADDMETHOD_CONST_NOBASE(supportReadOnlyAllocations, bool, false, ());
     ADDMETHOD_CONST_NOBASE(isBlitCopyRequiredForLocalMemory, bool, true, (const RootDeviceEnvironment &rootDeviceEnvironment, const GraphicsAllocation &allocation));
diff --git a/shared/test/unit_test/os_interface/windows/wddm_memory_manager_tests.cpp b/shared/test/unit_test/os_interface/windows/wddm_memory_manager_tests.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022-2024 Intel Corporation
+ * Copyright (C) 2022-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -142,11 +142,11 @@ TEST_F(WddmMemoryManagerTests, GivenNotCompressedAndNotLockableAllocationTypeWhe
     memoryManager->freeGraphicsMemory(graphicsAllocation);
 }
 
-TEST_F(WddmMemoryManagerTests, GivenOverrideAllocationCacheableWhenAllocateUsingKmdAndMapToCpuVaThenOverrideAllocationCacheable) {
+TEST_F(WddmMemoryManagerTests, GivenoverrideAllocationCpuCacheableWhenAllocateUsingKmdAndMapToCpuVaThenoverrideAllocationCpuCacheable) {
     NEO::AllocationData allocData = {};
     allocData.type = NEO::AllocationType::commandBuffer;
     auto mockProductHelper = std::make_unique<MockProductHelper>();
-    mockProductHelper->overrideAllocationCacheableResult = true;
+    mockProductHelper->overrideAllocationCpuCacheableResult = true;
     executionEnvironment->rootDeviceEnvironments[0]->productHelper.reset(mockProductHelper.release());
 
     memoryManager->callBaseAllocateGraphicsMemoryUsingKmdAndMapItToCpuVA = true;
diff --git a/shared/test/unit_test/xe2_hpg_core/lnl/product_helper_tests_lnl.cpp b/shared/test/unit_test/xe2_hpg_core/lnl/product_helper_tests_lnl.cpp
@@ -108,13 +108,13 @@ LNLTEST_F(LnlProductHelper, givenProductHelperWhenCallIsCachingOnCpuAvailableThe
     EXPECT_FALSE(productHelper->isCachingOnCpuAvailable());
 }
 
-LNLTEST_F(LnlProductHelper, givenProductHelperWhenCheckOverrideAllocationCacheableThenTrueIsReturnedForCommandBuffer) {
+LNLTEST_F(LnlProductHelper, givenProductHelperWhenCheckoverrideAllocationCpuCacheableThenTrueIsReturnedForCommandBuffer) {
     AllocationData allocationData{};
     allocationData.type = AllocationType::commandBuffer;
-    EXPECT_TRUE(productHelper->overrideAllocationCacheable(allocationData));
+    EXPECT_TRUE(productHelper->overrideAllocationCpuCacheable(allocationData));
 
     allocationData.type = AllocationType::buffer;
-    EXPECT_FALSE(productHelper->overrideAllocationCacheable(allocationData));
+    EXPECT_FALSE(productHelper->overrideAllocationCpuCacheable(allocationData));
 }
 
 LNLTEST_F(LnlProductHelper, givenExternalHostPtrWhenMitigateDcFlushThenOverrideCacheable) {
@@ -123,7 +123,7 @@ LNLTEST_F(LnlProductHelper, givenExternalHostPtrWhenMitigateDcFlushThenOverrideC
 
     AllocationData allocationData{};
     allocationData.type = AllocationType::externalHostPtr;
-    EXPECT_FALSE(productHelper->overrideAllocationCacheable(allocationData));
+    EXPECT_FALSE(productHelper->overrideAllocationCpuCacheable(allocationData));
 
     debugManager.flags.AllowDcFlush.set(0);
 
@@ -132,7 +132,8 @@ LNLTEST_F(LnlProductHelper, givenExternalHostPtrWhenMitigateDcFlushThenOverrideC
         allocationData.type = allocationType;
         switch (allocationData.type) {
         case AllocationType::commandBuffer:
-            EXPECT_TRUE(productHelper->overrideAllocationCacheable(allocationData));
+        case AllocationType::timestampPacketTagBuffer:
+            EXPECT_TRUE(productHelper->overrideAllocationCpuCacheable(allocationData));
             break;
         case AllocationType::externalHostPtr:
         case AllocationType::bufferHostMemory:
@@ -141,11 +142,11 @@ LNLTEST_F(LnlProductHelper, givenExternalHostPtrWhenMitigateDcFlushThenOverrideC
         case AllocationType::svmZeroCopy:
         case AllocationType::internalHostMemory:
         case AllocationType::printfSurface:
-            EXPECT_TRUE(productHelper->overrideAllocationCacheable(allocationData));
+            EXPECT_TRUE(productHelper->overrideAllocationCpuCacheable(allocationData));
             EXPECT_TRUE(productHelper->overrideCacheableForDcFlushMitigation(allocationData.type));
             break;
         default:
-            EXPECT_FALSE(productHelper->overrideAllocationCacheable(allocationData));
+            EXPECT_FALSE(productHelper->overrideAllocationCpuCacheable(allocationData));
             EXPECT_FALSE(productHelper->overrideCacheableForDcFlushMitigation(allocationData.type));
             break;
         }
diff --git a/shared/test/unit_test/xe3_core/ptl/product_helper_tests_ptl.cpp b/shared/test/unit_test/xe3_core/ptl/product_helper_tests_ptl.cpp
@@ -46,13 +46,13 @@ PTLTEST_F(PtlProductHelper, givenProductHelperWhenCheckDirectSubmissionSupported
     EXPECT_TRUE(productHelper->isDirectSubmissionSupported(releaseHelper));
 }
 
-PTLTEST_F(PtlProductHelper, givenProductHelperWhenCheckOverrideAllocationCacheableThenTrueIsReturnedForCommandBuffer) {
+PTLTEST_F(PtlProductHelper, givenProductHelperWhenCheckoverrideAllocationCpuCacheableThenTrueIsReturnedForCommandBuffer) {
     AllocationData allocationData{};
     allocationData.type = AllocationType::commandBuffer;
-    EXPECT_TRUE(productHelper->overrideAllocationCacheable(allocationData));
+    EXPECT_TRUE(productHelper->overrideAllocationCpuCacheable(allocationData));
 
     allocationData.type = AllocationType::buffer;
-    EXPECT_FALSE(productHelper->overrideAllocationCacheable(allocationData));
+    EXPECT_FALSE(productHelper->overrideAllocationCpuCacheable(allocationData));
 }
 
 PTLTEST_F(PtlProductHelper, givenExternalHostPtrWhenMitigateDcFlushThenOverrideCacheable) {
@@ -61,7 +61,7 @@ PTLTEST_F(PtlProductHelper, givenExternalHostPtrWhenMitigateDcFlushThenOverrideC
 
     AllocationData allocationData{};
     allocationData.type = AllocationType::externalHostPtr;
-    EXPECT_FALSE(productHelper->overrideAllocationCacheable(allocationData));
+    EXPECT_FALSE(productHelper->overrideAllocationCpuCacheable(allocationData));
 
     debugManager.flags.AllowDcFlush.set(0);
 
@@ -70,7 +70,8 @@ PTLTEST_F(PtlProductHelper, givenExternalHostPtrWhenMitigateDcFlushThenOverrideC
         allocationData.type = allocationType;
         switch (allocationData.type) {
         case AllocationType::commandBuffer:
-            EXPECT_TRUE(productHelper->overrideAllocationCacheable(allocationData));
+        case AllocationType::timestampPacketTagBuffer:
+            EXPECT_TRUE(productHelper->overrideAllocationCpuCacheable(allocationData));
             break;
         case AllocationType::externalHostPtr:
         case AllocationType::bufferHostMemory:
@@ -79,11 +80,11 @@ PTLTEST_F(PtlProductHelper, givenExternalHostPtrWhenMitigateDcFlushThenOverrideC
         case AllocationType::svmZeroCopy:
         case AllocationType::internalHostMemory:
         case AllocationType::printfSurface:
-            EXPECT_TRUE(productHelper->overrideAllocationCacheable(allocationData));
+            EXPECT_TRUE(productHelper->overrideAllocationCpuCacheable(allocationData));
             EXPECT_TRUE(productHelper->overrideCacheableForDcFlushMitigation(allocationData.type));
             break;
         default:
-            EXPECT_FALSE(productHelper->overrideAllocationCacheable(allocationData));
+            EXPECT_FALSE(productHelper->overrideAllocationCpuCacheable(allocationData));
             EXPECT_FALSE(productHelper->overrideCacheableForDcFlushMitigation(allocationData.type));
             break;
         }
diff --git a/shared/test/unit_test/xe_hpg_core/mtl/product_helper_tests_mtl.cpp b/shared/test/unit_test/xe_hpg_core/mtl/product_helper_tests_mtl.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022-2024 Intel Corporation
+ * Copyright (C) 2022-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -72,11 +72,11 @@ MTLTEST_F(MtlProductHelper, givenMtlWithoutHwIpVersionInHwInfoWhenGettingIpVersi
     EXPECT_EQ(compilerProductHelper->getDefaultHwIpVersion(), compilerProductHelper->getHwIpVersion(hwInfo));
 }
 
-MTLTEST_F(MtlProductHelper, givenProductHelperWhenCheckOverrideAllocationCacheableThenTrueIsReturnedForCommandBuffer) {
+MTLTEST_F(MtlProductHelper, givenProductHelperWhenCheckoverrideAllocationCpuCacheableThenTrueIsReturnedForCommandBuffer) {
     AllocationData allocationData{};
     allocationData.type = AllocationType::commandBuffer;
-    EXPECT_TRUE(productHelper->overrideAllocationCacheable(allocationData));
+    EXPECT_TRUE(productHelper->overrideAllocationCpuCacheable(allocationData));
 
     allocationData.type = AllocationType::buffer;
-    EXPECT_FALSE(productHelper->overrideAllocationCacheable(allocationData));
+    EXPECT_FALSE(productHelper->overrideAllocationCpuCacheable(allocationData));
 }

Original file line number	Diff line number	Diff line change
`@@ -1980,7 +1980,7 @@ inline std::unique_ptr<Gmm> DrmMemoryManager::makeGmmIfSingleHandle(const Alloca`
`1980`	`1980`	`gmmRequirements.allowLargePages = true;`
`1981`	`1981`	`gmmRequirements.preferCompressed = allocationData.flags.preferCompressed;`
`1982`	`1982`
`1983`		`- if (productHelper.overrideAllocationCacheable(allocationData)) {`
	`1983`	`+ if (productHelper.overrideAllocationCpuCacheable(allocationData)) {`
`1984`	`1984`	`gmmRequirements.overriderCacheable.enableOverride = true;`
`1985`	`1985`	`gmmRequirements.overriderCacheable.value = true;`
`1986`	`1986`	`}`
Original file line number	Diff line number	Diff line change
`@@ -219,7 +219,7 @@ uint64_t ProductHelperHw<gfxProduct>::getDeviceMemoryMaxBandWidthInBytesPerSecon`
`219`	`219`	`}`
`220`	`220`
`221`	`221`	`template <PRODUCT_FAMILY gfxProduct>`
`222`		`-bool ProductHelperHw<gfxProduct>::overrideAllocationCacheable(const AllocationData &allocationData) const {`
	`222`	`+bool ProductHelperHw<gfxProduct>::overrideAllocationCpuCacheable(const AllocationData &allocationData) const {`
`223`	`223`	`return false;`
`224`	`224`	`}`
`225`	`225`
Original file line number	Diff line number	Diff line change
`@@ -12,8 +12,8 @@`
`12`	`12`	`namespace NEO {`
`13`	`13`
`14`	`14`	`template <>`
`15`		`-bool ProductHelperHw<gfxProduct>::overrideAllocationCacheable(const AllocationData &allocationData) const {`
`16`		`- return allocationData.type == AllocationType::commandBuffer \|\| this->overrideCacheableForDcFlushMitigation(allocationData.type);`
	`15`	`+bool ProductHelperHw<gfxProduct>::overrideAllocationCpuCacheable(const AllocationData &allocationData) const {`
	`16`	`+ return allocationData.type == AllocationType::commandBuffer \|\| allocationData.type == AllocationType::timestampPacketTagBuffer \|\| this->overrideCacheableForDcFlushMitigation(allocationData.type);`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`template <>`
Original file line number	Diff line number	Diff line change
`@@ -10,8 +10,8 @@`
`10`	`10`	`namespace NEO {`
`11`	`11`
`12`	`12`	`template <>`
`13`		`-bool ProductHelperHw<gfxProduct>::overrideAllocationCacheable(const AllocationData &allocationData) const {`
`14`		`- return allocationData.type == AllocationType::commandBuffer \|\| this->overrideCacheableForDcFlushMitigation(allocationData.type);`
	`13`	`+bool ProductHelperHw<gfxProduct>::overrideAllocationCpuCacheable(const AllocationData &allocationData) const {`
	`14`	`+ return allocationData.type == AllocationType::commandBuffer \|\| allocationData.type == AllocationType::timestampPacketTagBuffer \|\| this->overrideCacheableForDcFlushMitigation(allocationData.type);`
`15`	`15`	`}`
`16`	`16`
`17`	`17`	`template <>`
Original file line number	Diff line number	Diff line change
`@@ -73,7 +73,7 @@ bool ProductHelperHw<gfxProduct>::isDeviceUsmPoolAllocatorSupported() const {`
`73`	`73`	`}`
`74`	`74`
`75`	`75`	`template <>`
`76`		`-bool ProductHelperHw<gfxProduct>::overrideAllocationCacheable(const AllocationData &allocationData) const {`
	`76`	`+bool ProductHelperHw<gfxProduct>::overrideAllocationCpuCacheable(const AllocationData &allocationData) const {`
`77`	`77`	`return allocationData.type == AllocationType::commandBuffer;`
`78`	`78`	`}`
`79`	`79`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`/*`
`2`		`- * Copyright (C) 2022-2024 Intel Corporation`
	`2`	`+ * Copyright (C) 2022-2025 Intel Corporation`
`3`	`3`	`*`
`4`	`4`	`* SPDX-License-Identifier: MIT`
`5`	`5`	`*`
`@@ -142,11 +142,11 @@ TEST_F(WddmMemoryManagerTests, GivenNotCompressedAndNotLockableAllocationTypeWhe`
`142`	`142`	`memoryManager->freeGraphicsMemory(graphicsAllocation);`
`143`	`143`	`}`
`144`	`144`
`145`		`-TEST_F(WddmMemoryManagerTests, GivenOverrideAllocationCacheableWhenAllocateUsingKmdAndMapToCpuVaThenOverrideAllocationCacheable) {`
	`145`	`+TEST_F(WddmMemoryManagerTests, GivenoverrideAllocationCpuCacheableWhenAllocateUsingKmdAndMapToCpuVaThenoverrideAllocationCpuCacheable) {`
`146`	`146`	`NEO::AllocationData allocData = {};`
`147`	`147`	`allocData.type = NEO::AllocationType::commandBuffer;`
`148`	`148`	`auto mockProductHelper = std::make_unique<MockProductHelper>();`
`149`		`- mockProductHelper->overrideAllocationCacheableResult = true;`
	`149`	`+ mockProductHelper->overrideAllocationCpuCacheableResult = true;`
`150`	`150`	`executionEnvironment->rootDeviceEnvironments[0]->productHelper.reset(mockProductHelper.release());`
`151`	`151`
`152`	`152`	`memoryManager->callBaseAllocateGraphicsMemoryUsingKmdAndMapItToCpuVA = true;`