refactor: Update MI_MEM_FENCE

ivysochyn · Compute-Runtime-Automation · commit a2aa64540496 · 2025-01-08T16:46:58.000+01:00
Refactors the MI_MEM_FENCE to align with the latest specification.

Related-To: NEO-13147

Signed-off-by: Vysochyn, Illia &lt;illia.vysochyn@intel.com&gt;
diff --git a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_memory_extension.cpp b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_memory_extension.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022-2024 Intel Corporation
+ * Copyright (C) 2022-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -760,7 +760,7 @@ HWTEST2_F(CommandListAppendWaitOnMem, givenAppendWaitOnMemWithHostMemAndNoScopeT
     auto itor = find<MI_MEM_FENCE *>(cmdList.begin(), cmdList.end());
     EXPECT_NE(cmdList.end(), itor);
     auto cmd = genCmdCast<MI_MEM_FENCE *>(*itor);
-    EXPECT_EQ(MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_ACQUIRE, cmd->getFenceType());
+    EXPECT_EQ(MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_ACQUIRE_FENCE, cmd->getFenceType());
 
     context->freeMem(dstBuffer);
 }
@@ -1328,7 +1328,7 @@ HWTEST2_F(ImmediateCommandListAppendWaitOnMem, givenAppendWaitOnMemWithHostMemAn
     auto itor = find<MI_MEM_FENCE *>(cmdList.begin(), cmdList.end());
     EXPECT_NE(cmdList.end(), itor);
     auto cmd = genCmdCast<MI_MEM_FENCE *>(*itor);
-    EXPECT_EQ(MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_ACQUIRE, cmd->getFenceType());
+    EXPECT_EQ(MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_ACQUIRE_FENCE, cmd->getFenceType());
 
     context->freeMem(dstBuffer);
 }
diff --git a/opencl/test/unit_test/xe2_hpg_core/command_stream_receiver_hw_tests_xe2_hpg_core.cpp b/opencl/test/unit_test/xe2_hpg_core/command_stream_receiver_hw_tests_xe2_hpg_core.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Intel Corporation
+ * Copyright (C) 2024-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -401,7 +401,7 @@ XE2_HPG_CORETEST_F(SystemMemoryFenceInDefaultConfigurationTestXe2HpgCore,
         ASSERT_NE(hwParser.cmdList.end(), itorMiMemFence);
         auto fenceCmd = genCmdCast<MI_MEM_FENCE *>(*itorMiMemFence);
         ASSERT_NE(nullptr, fenceCmd);
-        EXPECT_EQ(MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_RELEASE, fenceCmd->getFenceType());
+        EXPECT_EQ(MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_RELEASE_FENCE, fenceCmd->getFenceType());
     }
 }
 
@@ -439,7 +439,7 @@ XE2_HPG_CORETEST_F(SystemMemoryFenceInDefaultConfigurationTestXe2HpgCore,
         ASSERT_NE(hwParser.cmdList.end(), itorMiMemFence);
         auto fenceCmd = genCmdCast<MI_MEM_FENCE *>(*itorMiMemFence);
         ASSERT_NE(nullptr, fenceCmd);
-        EXPECT_EQ(MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_RELEASE, fenceCmd->getFenceType());
+        EXPECT_EQ(MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_RELEASE_FENCE, fenceCmd->getFenceType());
     }
 }
 
@@ -477,7 +477,7 @@ XE2_HPG_CORETEST_F(SystemMemoryFenceInDefaultConfigurationTestXe2HpgCore,
         ASSERT_NE(hwParser.cmdList.end(), itorMiMemFence);
         auto fenceCmd = genCmdCast<MI_MEM_FENCE *>(*itorMiMemFence);
         ASSERT_NE(nullptr, fenceCmd);
-        EXPECT_EQ(MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_RELEASE, fenceCmd->getFenceType());
+        EXPECT_EQ(MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_RELEASE_FENCE, fenceCmd->getFenceType());
     }
 
     auto event = castToObject<Event>(kernelEvent);
@@ -519,7 +519,7 @@ XE2_HPG_CORETEST_F(SystemMemoryFenceInDefaultConfigurationTestXe2HpgCore,
         ASSERT_NE(hwParser.cmdList.end(), itorMiMemFence);
         auto fenceCmd = genCmdCast<MI_MEM_FENCE *>(*itorMiMemFence);
         ASSERT_NE(nullptr, fenceCmd);
-        EXPECT_EQ(MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_RELEASE, fenceCmd->getFenceType());
+        EXPECT_EQ(MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_RELEASE_FENCE, fenceCmd->getFenceType());
     }
 
     auto event = castToObject<Event>(kernelEvent);
@@ -562,7 +562,7 @@ XE2_HPG_CORETEST_F(SystemMemoryFenceInDefaultConfigurationTestXe2HpgCore,
         ASSERT_NE(hwParser.cmdList.end(), itorMiMemFence);
         auto fenceCmd = genCmdCast<MI_MEM_FENCE *>(*itorMiMemFence);
         ASSERT_NE(nullptr, fenceCmd);
-        EXPECT_EQ(MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_RELEASE, fenceCmd->getFenceType());
+        EXPECT_EQ(MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_RELEASE_FENCE, fenceCmd->getFenceType());
     }
 
     auto event = castToObject<Event>(kernelEvent);
diff --git a/opencl/test/unit_test/xe_hpc_core/command_stream_receiver_hw_tests_xe_hpc_core.cpp b/opencl/test/unit_test/xe_hpc_core/command_stream_receiver_hw_tests_xe_hpc_core.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2021-2023 Intel Corporation
+ * Copyright (C) 2021-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -333,7 +333,7 @@ XE_HPC_CORETEST_F(SystemMemoryFenceInDefaultConfigurationTest,
     ASSERT_NE(hwParser.cmdList.end(), itorMiMemFence);
     auto fenceCmd = genCmdCast<MI_MEM_FENCE *>(*itorMiMemFence);
     ASSERT_NE(nullptr, fenceCmd);
-    EXPECT_EQ(MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_RELEASE, fenceCmd->getFenceType());
+    EXPECT_EQ(MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_RELEASE_FENCE, fenceCmd->getFenceType());
 }
 
 XE_HPC_CORETEST_F(SystemMemoryFenceInDefaultConfigurationTest,
@@ -376,7 +376,7 @@ XE_HPC_CORETEST_F(SystemMemoryFenceInDefaultConfigurationTest,
     ASSERT_NE(hwParser.cmdList.end(), itorMiMemFence);
     auto fenceCmd = genCmdCast<MI_MEM_FENCE *>(*itorMiMemFence);
     ASSERT_NE(nullptr, fenceCmd);
-    EXPECT_EQ(MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_RELEASE, fenceCmd->getFenceType());
+    EXPECT_EQ(MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_RELEASE_FENCE, fenceCmd->getFenceType());
 }
 
 XE_HPC_CORETEST_F(SystemMemoryFenceInDefaultConfigurationTest,
@@ -419,7 +419,7 @@ XE_HPC_CORETEST_F(SystemMemoryFenceInDefaultConfigurationTest,
     ASSERT_NE(hwParser.cmdList.end(), itorMiMemFence);
     auto fenceCmd = genCmdCast<MI_MEM_FENCE *>(*itorMiMemFence);
     ASSERT_NE(nullptr, fenceCmd);
-    EXPECT_EQ(MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_RELEASE, fenceCmd->getFenceType());
+    EXPECT_EQ(MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_RELEASE_FENCE, fenceCmd->getFenceType());
 
     auto event = castToObject<Event>(kernelEvent);
     event->release();
@@ -466,7 +466,7 @@ XE_HPC_CORETEST_F(SystemMemoryFenceInDefaultConfigurationTest,
     ASSERT_NE(hwParser.cmdList.end(), itorMiMemFence);
     auto fenceCmd = genCmdCast<MI_MEM_FENCE *>(*itorMiMemFence);
     ASSERT_NE(nullptr, fenceCmd);
-    EXPECT_EQ(MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_RELEASE, fenceCmd->getFenceType());
+    EXPECT_EQ(MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_RELEASE_FENCE, fenceCmd->getFenceType());
 
     auto event = castToObject<Event>(kernelEvent);
     event->release();
@@ -514,7 +514,7 @@ XE_HPC_CORETEST_F(SystemMemoryFenceInDefaultConfigurationTest,
     ASSERT_NE(hwParser.cmdList.end(), itorMiMemFence);
     auto fenceCmd = genCmdCast<MI_MEM_FENCE *>(*itorMiMemFence);
     ASSERT_NE(nullptr, fenceCmd);
-    EXPECT_EQ(MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_RELEASE, fenceCmd->getFenceType());
+    EXPECT_EQ(MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_RELEASE_FENCE, fenceCmd->getFenceType());
 
     auto event = castToObject<Event>(kernelEvent);
     event->release();
diff --git a/shared/source/generated/xe2_hpg_core/hw_cmds_generated_xe2_hpg_core.inl b/shared/source/generated/xe2_hpg_core/hw_cmds_generated_xe2_hpg_core.inl
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Intel Corporation
+ * Copyright (C) 2024-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -7188,9 +7188,9 @@ typedef struct tagMI_MEM_FENCE {
         uint32_t RawData[1];
     } TheStructure;
     typedef enum tagFENCE_TYPE {
-        FENCE_TYPE_RELEASE = 0x0,
-        FENCE_TYPE_ACQUIRE = 0x1,
-        FENCE_TYPE_MI_WRITE = 0x3,
+        FENCE_TYPE_RELEASE_FENCE = 0x0,
+        FENCE_TYPE_ACQUIRE_FENCE = 0x1,
+        FENCE_TYPE_MI_WRITE_FENCE = 0x3,
     } FENCE_TYPE;
     typedef enum tagMI_COMMAND_SUB_OPCODE {
         MI_COMMAND_SUB_OPCODE_MI_MEM_FENCE = 0x0,
@@ -7203,7 +7203,7 @@ typedef struct tagMI_MEM_FENCE {
     } COMMAND_TYPE;
     inline void init() {
         memset(&TheStructure, 0, sizeof(TheStructure));
-        TheStructure.Common.FenceType = FENCE_TYPE_RELEASE;
+        TheStructure.Common.FenceType = FENCE_TYPE_RELEASE_FENCE;
         TheStructure.Common.MiCommandSubOpcode = MI_COMMAND_SUB_OPCODE_MI_MEM_FENCE;
         TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_EXTENDED;
         TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND;
diff --git a/shared/source/generated/xe3_core/hw_cmds_generated_xe3_core.inl b/shared/source/generated/xe3_core/hw_cmds_generated_xe3_core.inl
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Intel Corporation
+ * Copyright (C) 2024-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -7225,9 +7225,9 @@ typedef struct tagMI_MEM_FENCE {
         uint32_t RawData[1];
     } TheStructure;
     typedef enum tagFENCE_TYPE {
-        FENCE_TYPE_RELEASE = 0x0,
-        FENCE_TYPE_ACQUIRE = 0x1,
-        FENCE_TYPE_MI_WRITE = 0x3,
+        FENCE_TYPE_RELEASE_FENCE = 0x0,
+        FENCE_TYPE_ACQUIRE_FENCE = 0x1,
+        FENCE_TYPE_MI_WRITE_FENCE = 0x3,
     } FENCE_TYPE;
     typedef enum tagMI_COMMAND_SUB_OPCODE {
         MI_COMMAND_SUB_OPCODE_MI_MEM_FENCE = 0x0,
@@ -7240,7 +7240,7 @@ typedef struct tagMI_MEM_FENCE {
     } COMMAND_TYPE;
     inline void init() {
         memset(&TheStructure, 0, sizeof(TheStructure));
-        TheStructure.Common.FenceType = FENCE_TYPE_RELEASE;
+        TheStructure.Common.FenceType = FENCE_TYPE_RELEASE_FENCE;
         TheStructure.Common.MiCommandSubOpcode = MI_COMMAND_SUB_OPCODE_MI_MEM_FENCE;
         TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_EXTENDED;
         TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND;
diff --git a/shared/source/generated/xe_hpc_core/hw_cmds_generated_xe_hpc_core.inl b/shared/source/generated/xe_hpc_core/hw_cmds_generated_xe_hpc_core.inl
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2021-2024 Intel Corporation
+ * Copyright (C) 2021-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -7057,14 +7057,14 @@ struct MI_MEM_FENCE {
     } TheStructure;
 
     typedef enum tagFENCE_TYPE {
-        FENCE_TYPE_RELEASE = 0x0,
-        FENCE_TYPE_ACQUIRE = 0x1,
+        FENCE_TYPE_RELEASE_FENCE = 0x0,
+        FENCE_TYPE_ACQUIRE_FENCE = 0x1,
     } FENCE_TYPE;
 
     inline void init() {
         memset(&TheStructure, 0, sizeof(TheStructure));
         TheStructure.Common.MiCommandOpcode = 0x9;
-        TheStructure.Common.FenceType = FENCE_TYPE::FENCE_TYPE_RELEASE;
+        TheStructure.Common.FenceType = FENCE_TYPE::FENCE_TYPE_RELEASE_FENCE;
     }
 
     static MI_MEM_FENCE sInit() {
diff --git a/shared/source/xe2_hpg_core/gfx_core_helper_xe2_hpg_core.cpp b/shared/source/xe2_hpg_core/gfx_core_helper_xe2_hpg_core.cpp
@@ -141,9 +141,9 @@ void MemorySynchronizationCommands<Family>::setAdditionalSynchronization(void *&
     if (programGlobalFenceAsMiMemFenceCommandInCommandStream == AdditionalSynchronizationType::fence) {
         MI_MEM_FENCE miMemFence = Family::cmdInitMemFence;
         if (acquire) {
-            miMemFence.setFenceType(Family::MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_ACQUIRE);
+            miMemFence.setFenceType(Family::MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_ACQUIRE_FENCE);
         } else {
-            miMemFence.setFenceType(Family::MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_RELEASE);
+            miMemFence.setFenceType(Family::MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_RELEASE_FENCE);
         }
         *reinterpret_cast<MI_MEM_FENCE *>(commandsBuffer) = miMemFence;
         commandsBuffer = ptrOffset(commandsBuffer, sizeof(MI_MEM_FENCE));
diff --git a/shared/source/xe3_core/gfx_core_helper_xe3_core.cpp b/shared/source/xe3_core/gfx_core_helper_xe3_core.cpp
@@ -141,9 +141,9 @@ void MemorySynchronizationCommands<Family>::setAdditionalSynchronization(void *&
     if (programGlobalFenceAsMiMemFenceCommandInCommandStream == AdditionalSynchronizationType::fence) {
         MI_MEM_FENCE miMemFence = Family::cmdInitMemFence;
         if (acquire) {
-            miMemFence.setFenceType(Family::MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_ACQUIRE);
+            miMemFence.setFenceType(Family::MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_ACQUIRE_FENCE);
         } else {
-            miMemFence.setFenceType(Family::MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_RELEASE);
+            miMemFence.setFenceType(Family::MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_RELEASE_FENCE);
         }
         *reinterpret_cast<MI_MEM_FENCE *>(commandsBuffer) = miMemFence;
         commandsBuffer = ptrOffset(commandsBuffer, sizeof(MI_MEM_FENCE));
diff --git a/shared/source/xe_hpc_core/gfx_core_helper_xe_hpc_core.cpp b/shared/source/xe_hpc_core/gfx_core_helper_xe_hpc_core.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2021-2024 Intel Corporation
+ * Copyright (C) 2021-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -167,9 +167,9 @@ void MemorySynchronizationCommands<Family>::setAdditionalSynchronization(void *&
     if (programGlobalFenceAsMiMemFenceCommandInCommandStream) {
         MI_MEM_FENCE miMemFence = Family::cmdInitMemFence;
         if (acquire) {
-            miMemFence.setFenceType(Family::MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_ACQUIRE);
+            miMemFence.setFenceType(Family::MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_ACQUIRE_FENCE);
         } else {
-            miMemFence.setFenceType(Family::MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_RELEASE);
+            miMemFence.setFenceType(Family::MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_RELEASE_FENCE);
         }
         *reinterpret_cast<MI_MEM_FENCE *>(commandsBuffer) = miMemFence;
         commandsBuffer = ptrOffset(commandsBuffer, sizeof(MI_MEM_FENCE));
diff --git a/shared/test/unit_test/direct_submission/direct_submission_tests_2.cpp b/shared/test/unit_test/direct_submission/direct_submission_tests_2.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2024 Intel Corporation
+ * Copyright (C) 2020-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -77,7 +77,7 @@ struct DirectSubmissionDispatchMiMemFenceTest : public DirectSubmissionDispatchB
 
                     EXPECT_NE(0u, sysFenceAddress->getSystemMemoryFenceAddress());
                 } else if (auto miMemFence = genCmdCast<MI_MEM_FENCE *>(it)) {
-                    if (miMemFence->getFenceType() == MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_ACQUIRE) {
+                    if (miMemFence->getFenceType() == MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_ACQUIRE_FENCE) {
                         EXPECT_TRUE(id > systemMemoryFenceId);
 
                         fenceCount++;
diff --git a/shared/test/unit_test/xe2_hpg_core/gfx_core_helper_tests_xe2_hpg_core.cpp b/shared/test/unit_test/xe2_hpg_core/gfx_core_helper_tests_xe2_hpg_core.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Intel Corporation
+ * Copyright (C) 2024-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -560,7 +560,7 @@ XE2_HPG_CORETEST_F(GfxCoreHelperTestsXe2HpgCore, givenDefaultMemorySynchronizati
         EXPECT_EQ(1u, hwParser.cmdList.size());
         auto fenceCmd = genCmdCast<MI_MEM_FENCE *>(*hwParser.cmdList.begin());
         ASSERT_NE(nullptr, fenceCmd);
-        EXPECT_EQ(MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_RELEASE, fenceCmd->getFenceType());
+        EXPECT_EQ(MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_RELEASE_FENCE, fenceCmd->getFenceType());
     }
 }
 
@@ -608,7 +608,7 @@ XE2_HPG_CORETEST_F(GfxCoreHelperTestsXe2HpgCore, givenProgramGlobalFenceAsMiMemF
     EXPECT_EQ(1u, hwParser.cmdList.size());
     auto fenceCmd = genCmdCast<MI_MEM_FENCE *>(*hwParser.cmdList.begin());
     ASSERT_NE(nullptr, fenceCmd);
-    EXPECT_EQ(MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_RELEASE, fenceCmd->getFenceType());
+    EXPECT_EQ(MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_RELEASE_FENCE, fenceCmd->getFenceType());
 }
 
 using ProductHelperTestXe2HpgCore = Test<DeviceFixture>;
diff --git a/shared/test/unit_test/xe3_core/gfx_core_helper_xe3_core_tests.cpp b/shared/test/unit_test/xe3_core/gfx_core_helper_xe3_core_tests.cpp
@@ -556,7 +556,7 @@ XE3_CORETEST_F(GfxCoreHelperTestsXe3Core, givenDefaultMemorySynchronizationComma
         EXPECT_EQ(1u, hwParser.cmdList.size());
         auto fenceCmd = genCmdCast<MI_MEM_FENCE *>(*hwParser.cmdList.begin());
         ASSERT_NE(nullptr, fenceCmd);
-        EXPECT_EQ(MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_RELEASE, fenceCmd->getFenceType());
+        EXPECT_EQ(MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_RELEASE_FENCE, fenceCmd->getFenceType());
     }
 }
 
@@ -604,7 +604,7 @@ XE3_CORETEST_F(GfxCoreHelperTestsXe3Core, givenProgramGlobalFenceAsMiMemFenceCom
     EXPECT_EQ(1u, hwParser.cmdList.size());
     auto fenceCmd = genCmdCast<MI_MEM_FENCE *>(*hwParser.cmdList.begin());
     ASSERT_NE(nullptr, fenceCmd);
-    EXPECT_EQ(MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_RELEASE, fenceCmd->getFenceType());
+    EXPECT_EQ(MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_RELEASE_FENCE, fenceCmd->getFenceType());
 }
 
 using ProductHelperTestXe3Core = Test<DeviceFixture>;
diff --git a/shared/test/unit_test/xe_hpc_core/pvc/gfx_core_helper_tests_pvc.cpp b/shared/test/unit_test/xe_hpc_core/pvc/gfx_core_helper_tests_pvc.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022-2024 Intel Corporation
+ * Copyright (C) 2022-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -153,7 +153,7 @@ PVCTEST_F(GfxCoreHelperTestsPvc, givenMemorySynchronizationCommandsWhenAddingSyn
 
             auto fenceCmd = genCmdCast<MI_MEM_FENCE *>(*hwParser.cmdList.begin());
             ASSERT_NE(nullptr, fenceCmd);
-            EXPECT_EQ(MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_RELEASE, fenceCmd->getFenceType());
+            EXPECT_EQ(MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_RELEASE_FENCE, fenceCmd->getFenceType());
         }
     }
 }

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`	`*`
`@@ -760,7 +760,7 @@ HWTEST2_F(CommandListAppendWaitOnMem, givenAppendWaitOnMemWithHostMemAndNoScopeT`
`760`	`760`	`auto itor = find<MI_MEM_FENCE *>(cmdList.begin(), cmdList.end());`
`761`	`761`	`EXPECT_NE(cmdList.end(), itor);`
`762`	`762`	`auto cmd = genCmdCast<MI_MEM_FENCE >(itor);`
`763`		`- EXPECT_EQ(MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_ACQUIRE, cmd->getFenceType());`
	`763`	`+ EXPECT_EQ(MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_ACQUIRE_FENCE, cmd->getFenceType());`
`764`	`764`
`765`	`765`	`context->freeMem(dstBuffer);`
`766`	`766`	`}`
`@@ -1328,7 +1328,7 @@ HWTEST2_F(ImmediateCommandListAppendWaitOnMem, givenAppendWaitOnMemWithHostMemAn`
`1328`	`1328`	`auto itor = find<MI_MEM_FENCE *>(cmdList.begin(), cmdList.end());`
`1329`	`1329`	`EXPECT_NE(cmdList.end(), itor);`
`1330`	`1330`	`auto cmd = genCmdCast<MI_MEM_FENCE >(itor);`
`1331`		`- EXPECT_EQ(MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_ACQUIRE, cmd->getFenceType());`
	`1331`	`+ EXPECT_EQ(MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_ACQUIRE_FENCE, cmd->getFenceType());`
`1332`	`1332`
`1333`	`1333`	`context->freeMem(dstBuffer);`
`1334`	`1334`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`/*`
`2`		`- * Copyright (C) 2024 Intel Corporation`
	`2`	`+ * Copyright (C) 2024-2025 Intel Corporation`
`3`	`3`	`*`
`4`	`4`	`* SPDX-License-Identifier: MIT`
`5`	`5`	`*`
`@@ -401,7 +401,7 @@ XE2_HPG_CORETEST_F(SystemMemoryFenceInDefaultConfigurationTestXe2HpgCore,`
`401`	`401`	`ASSERT_NE(hwParser.cmdList.end(), itorMiMemFence);`
`402`	`402`	`auto fenceCmd = genCmdCast<MI_MEM_FENCE >(itorMiMemFence);`
`403`	`403`	`ASSERT_NE(nullptr, fenceCmd);`
`404`		`- EXPECT_EQ(MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_RELEASE, fenceCmd->getFenceType());`
	`404`	`+ EXPECT_EQ(MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_RELEASE_FENCE, fenceCmd->getFenceType());`
`405`	`405`	`}`
`406`	`406`	`}`
`407`	`407`
`@@ -439,7 +439,7 @@ XE2_HPG_CORETEST_F(SystemMemoryFenceInDefaultConfigurationTestXe2HpgCore,`
`439`	`439`	`ASSERT_NE(hwParser.cmdList.end(), itorMiMemFence);`
`440`	`440`	`auto fenceCmd = genCmdCast<MI_MEM_FENCE >(itorMiMemFence);`
`441`	`441`	`ASSERT_NE(nullptr, fenceCmd);`
`442`		`- EXPECT_EQ(MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_RELEASE, fenceCmd->getFenceType());`
	`442`	`+ EXPECT_EQ(MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_RELEASE_FENCE, fenceCmd->getFenceType());`
`443`	`443`	`}`
`444`	`444`	`}`
`445`	`445`
`@@ -477,7 +477,7 @@ XE2_HPG_CORETEST_F(SystemMemoryFenceInDefaultConfigurationTestXe2HpgCore,`
`477`	`477`	`ASSERT_NE(hwParser.cmdList.end(), itorMiMemFence);`
`478`	`478`	`auto fenceCmd = genCmdCast<MI_MEM_FENCE >(itorMiMemFence);`
`479`	`479`	`ASSERT_NE(nullptr, fenceCmd);`
`480`		`- EXPECT_EQ(MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_RELEASE, fenceCmd->getFenceType());`
	`480`	`+ EXPECT_EQ(MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_RELEASE_FENCE, fenceCmd->getFenceType());`
`481`	`481`	`}`
`482`	`482`
`483`	`483`	`auto event = castToObject<Event>(kernelEvent);`
`@@ -519,7 +519,7 @@ XE2_HPG_CORETEST_F(SystemMemoryFenceInDefaultConfigurationTestXe2HpgCore,`
`519`	`519`	`ASSERT_NE(hwParser.cmdList.end(), itorMiMemFence);`
`520`	`520`	`auto fenceCmd = genCmdCast<MI_MEM_FENCE >(itorMiMemFence);`
`521`	`521`	`ASSERT_NE(nullptr, fenceCmd);`
`522`		`- EXPECT_EQ(MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_RELEASE, fenceCmd->getFenceType());`
	`522`	`+ EXPECT_EQ(MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_RELEASE_FENCE, fenceCmd->getFenceType());`
`523`	`523`	`}`
`524`	`524`
`525`	`525`	`auto event = castToObject<Event>(kernelEvent);`
`@@ -562,7 +562,7 @@ XE2_HPG_CORETEST_F(SystemMemoryFenceInDefaultConfigurationTestXe2HpgCore,`
`562`	`562`	`ASSERT_NE(hwParser.cmdList.end(), itorMiMemFence);`
`563`	`563`	`auto fenceCmd = genCmdCast<MI_MEM_FENCE >(itorMiMemFence);`
`564`	`564`	`ASSERT_NE(nullptr, fenceCmd);`
`565`		`- EXPECT_EQ(MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_RELEASE, fenceCmd->getFenceType());`
	`565`	`+ EXPECT_EQ(MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_RELEASE_FENCE, fenceCmd->getFenceType());`
`566`	`566`	`}`
`567`	`567`
`568`	`568`	`auto event = castToObject<Event>(kernelEvent);`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`/*`
`2`		`- * Copyright (C) 2021-2024 Intel Corporation`
	`2`	`+ * Copyright (C) 2021-2025 Intel Corporation`
`3`	`3`	`*`
`4`	`4`	`* SPDX-License-Identifier: MIT`
`5`	`5`	`*`
`@@ -167,9 +167,9 @@ void MemorySynchronizationCommands<Family>::setAdditionalSynchronization(void *&`
`167`	`167`	`if (programGlobalFenceAsMiMemFenceCommandInCommandStream) {`
`168`	`168`	`MI_MEM_FENCE miMemFence = Family::cmdInitMemFence;`
`169`	`169`	`if (acquire) {`
`170`		`- miMemFence.setFenceType(Family::MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_ACQUIRE);`
	`170`	`+ miMemFence.setFenceType(Family::MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_ACQUIRE_FENCE);`
`171`	`171`	`} else {`
`172`		`- miMemFence.setFenceType(Family::MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_RELEASE);`
	`172`	`+ miMemFence.setFenceType(Family::MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_RELEASE_FENCE);`
`173`	`173`	`}`
`174`	`174`	`reinterpret_cast<MI_MEM_FENCE >(commandsBuffer) = miMemFence;`
`175`	`175`	`commandsBuffer = ptrOffset(commandsBuffer, sizeof(MI_MEM_FENCE));`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`/*`
`2`		`- * Copyright (C) 2020-2024 Intel Corporation`
	`2`	`+ * Copyright (C) 2020-2025 Intel Corporation`
`3`	`3`	`*`
`4`	`4`	`* SPDX-License-Identifier: MIT`
`5`	`5`	`*`
`@@ -77,7 +77,7 @@ struct DirectSubmissionDispatchMiMemFenceTest : public DirectSubmissionDispatchB`
`77`	`77`
`78`	`78`	`EXPECT_NE(0u, sysFenceAddress->getSystemMemoryFenceAddress());`
`79`	`79`	`} else if (auto miMemFence = genCmdCast<MI_MEM_FENCE *>(it)) {`
`80`		`- if (miMemFence->getFenceType() == MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_ACQUIRE) {`
	`80`	`+ if (miMemFence->getFenceType() == MI_MEM_FENCE::FENCE_TYPE::FENCE_TYPE_ACQUIRE_FENCE) {`
`81`	`81`	`EXPECT_TRUE(id > systemMemoryFenceId);`
`82`	`82`
`83`	`83`	`fenceCount++;`