fix: split hostptr into aligned and misaligned

ddabek-i · Compute-Runtime-Automation · commit dc1d0d83800a · 2025-02-13T14:04:14.000+01:00
Split hostptr allocation types into aligned to 4KB and misaligned
(offset by 4 bytes).

Should reduce test noise from hostptrs sometimes being aligned by
chance.

Signed-off-by: Dominik Dabek &lt;dominik.dabek@intel.com&gt;
diff --git a/TESTS.md b/TESTS.md
diff --git a/source/benchmarks/api_overhead_benchmark/gtest/reset_command_list.cpp b/source/benchmarks/api_overhead_benchmark/gtest/reset_command_list.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022-2023 Intel Corporation
+ * Copyright (C) 2022-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -31,7 +31,7 @@ INSTANTIATE_TEST_SUITE_P(
     ResetCommandListTest,
     ResetCommandListTest,
     ::testing::Combine(
-        ::testing::Values(UsmMemoryPlacement::Host, UsmMemoryPlacement::Device, UsmMemoryPlacement::Shared, UsmMemoryPlacement::NonUsm),
+        ::testing::Values(UsmMemoryPlacement::Host, UsmMemoryPlacement::Device, UsmMemoryPlacement::Shared, UsmMemoryPlacement::NonUsm4KBAligned),
         ::testing::Values(4,
                           1 * MemoryConstants::megaByte,
                           128 * MemoryConstants::megaByte),
diff --git a/source/benchmarks/memory_benchmark/implementations/ocl/write_buffer_ocl.cpp b/source/benchmarks/memory_benchmark/implementations/ocl/write_buffer_ocl.cpp
@@ -50,8 +50,7 @@ static TestResult run(const WriteBufferArguments &arguments, Statistics &statist
     // Create hostptr
     HostptrReuseHelper::Alloc hostptrAlloc{};
     ASSERT_CL_SUCCESS(HostptrReuseHelper::allocateBufferHostptr(opencl, arguments.reuse, arguments.size, hostptrAlloc));
-    auto placement = arguments.reuse == HostptrReuseMode::Usm ? UsmMemoryPlacement::Host : UsmMemoryPlacement::NonUsm;
-    ASSERT_CL_SUCCESS(BufferContentsHelperOcl::fillUsmBufferOrHostPtr(opencl.commandQueue, hostptrAlloc.ptr, arguments.size, placement, arguments.contents));
+    ASSERT_CL_SUCCESS(BufferContentsHelperOcl::fillUsmBufferOrHostPtr(opencl.commandQueue, hostptrAlloc.ptr, arguments.size, arguments.reuse, arguments.contents));
 
     // Warmup
     ASSERT_CL_SUCCESS(clEnqueueWriteBuffer(opencl.commandQueue, buffer, CL_BLOCKING, 0, arguments.size, hostptrAlloc.ptr, 0, nullptr, nullptr));
diff --git a/source/benchmarks/memory_benchmark/implementations/ocl/write_image_ocl.cpp b/source/benchmarks/memory_benchmark/implementations/ocl/write_image_ocl.cpp
@@ -61,8 +61,7 @@ static TestResult run(const WriteImageArguments &arguments, Statistics &statisti
     // Create hostptr
     HostptrReuseHelper::Alloc hostptrAlloc{};
     ASSERT_CL_SUCCESS(HostptrReuseHelper::allocateBufferHostptr(opencl, arguments.hostPtrPlacement, imageSizeInBytes, hostptrAlloc));
-    auto placement = arguments.hostPtrPlacement == HostptrReuseMode::Usm ? UsmMemoryPlacement::Host : UsmMemoryPlacement::NonUsm;
-    ASSERT_CL_SUCCESS(BufferContentsHelperOcl::fillUsmBufferOrHostPtr(opencl.commandQueue, hostptrAlloc.ptr, imageSizeInBytes, placement, BufferContents::Random));
+    ASSERT_CL_SUCCESS(BufferContentsHelperOcl::fillUsmBufferOrHostPtr(opencl.commandQueue, hostptrAlloc.ptr, imageSizeInBytes, arguments.hostPtrPlacement, BufferContents::Random));
 
     // Warmup
     const size_t origin[] = {0, 0, 0};
diff --git a/source/framework/argument/enum/hostptr_reuse_mode_argument.h b/source/framework/argument/enum/hostptr_reuse_mode_argument.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 Intel Corporation
+ * Copyright (C) 2022-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -20,8 +20,8 @@ struct HostptrBufferReuseModeArgument : EnumArgument<HostptrBufferReuseModeArgum
 
     const static inline std::string enumName = "Buffer hostptr reuse mode";
     const static inline EnumType invalidEnumValue = EnumType::Unknown;
-    const static inline EnumType enumValues[3] = {EnumType::None, EnumType::Usm, EnumType::Map};
-    const static inline std::string enumValuesNames[3] = {"None", "Usm", "Map"};
+    const static inline EnumType enumValues[4] = {EnumType::Aligned4KB, EnumType::Misaligned, EnumType::Usm, EnumType::Map};
+    const static inline std::string enumValuesNames[4] = {"Aligned4KB", "Misaligned", "Usm", "Map"};
 };
 
 struct HostptrImageReuseModeArgument : EnumArgument<HostptrImageReuseModeArgument, HostptrReuseMode> {
@@ -34,6 +34,6 @@ struct HostptrImageReuseModeArgument : EnumArgument<HostptrImageReuseModeArgumen
 
     const static inline std::string enumName = "Image hostptr reuse mode";
     const static inline EnumType invalidEnumValue = EnumType::Unknown;
-    const static inline EnumType enumValues[2] = {EnumType::None, EnumType::Map};
-    const static inline std::string enumValuesNames[2] = {"None", "Map"};
+    const static inline EnumType enumValues[3] = {EnumType::Aligned4KB, EnumType::Misaligned, EnumType::Map};
+    const static inline std::string enumValuesNames[3] = {"Aligned4KB", "Misaligned", "Map"};
 };
diff --git a/source/framework/argument/enum/usm_memory_placement_argument.h b/source/framework/argument/enum/usm_memory_placement_argument.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022-2024 Intel Corporation
+ * Copyright (C) 2022-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -20,8 +20,8 @@ struct UsmMemoryPlacementArgument : EnumArgument<UsmMemoryPlacementArgument, Usm
 
     const static inline std::string enumName = "memory placement";
     const static inline EnumType invalidEnumValue = EnumType::Unknown;
-    const static inline EnumType enumValues[8] = {EnumType::Device, EnumType::Host, EnumType::Shared, EnumType::NonUsm, EnumType::NonUsmImported, EnumType::NonUsmMapped, EnumType::NonUsm2MBAligned, EnumType::NonUsmImported2MBAligned};
-    const static inline EnumType limitedTargets[3] = {EnumType::Device, EnumType::Host, EnumType::NonUsm};
+    const static inline EnumType enumValues[10] = {EnumType::Device, EnumType::Host, EnumType::Shared, EnumType::NonUsmMapped, EnumType::NonUsmMisaligned, EnumType::NonUsm4KBAligned, EnumType::NonUsm2MBAligned, EnumType::NonUsmImportedMisaligned, EnumType::NonUsmImported4KBAligned, EnumType::NonUsmImported2MBAligned};
+    const static inline EnumType limitedTargets[3] = {EnumType::Device, EnumType::Host, EnumType::NonUsm4KBAligned};
     const static inline EnumType deviceAndHost[2] = {EnumType::Device, EnumType::Host};
-    const static inline std::string enumValuesNames[8] = {"Device", "Host", "Shared", "non-USM", "non-USM-imported", "non-USM-mapped", "non-usm2MBAligned", "non-USM2MBAligned-imported"};
+    const static inline std::string enumValuesNames[10] = {"Device", "Host", "Shared", "non-USM-mapped", "non-USMmisaligned", "non-USM4KBAligned", "non-USM2MBAligned", "non-USMmisaligned-imported", "non-USM4KBAligned-imported", "non-USM2MBAligned-imported"};
 };
diff --git a/source/framework/enum/hostptr_reuse_mode.h b/source/framework/enum/hostptr_reuse_mode.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 Intel Corporation
+ * Copyright (C) 2022-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -10,7 +10,8 @@
 enum class HostptrReuseMode {
     Unknown,
 
-    None,
+    Aligned4KB,
+    Misaligned,
     Usm,
     Map,
 };
diff --git a/source/framework/enum/usm_memory_placement.h b/source/framework/enum/usm_memory_placement.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022-2024 Intel Corporation
+ * Copyright (C) 2022-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -14,15 +14,19 @@ enum class UsmMemoryPlacement {
     Host,
     Device,
     Shared,
-    NonUsm,
-    NonUsmImported,
     NonUsmMapped,
+    NonUsmMisaligned,
+    NonUsm4KBAligned,
     NonUsm2MBAligned,
-    NonUsmImported2MBAligned
+    NonUsmImportedMisaligned,
+    NonUsmImported4KBAligned,
+    NonUsmImported2MBAligned,
 };
 
 inline constexpr bool requiresImport(UsmMemoryPlacement inputType) {
-    if (inputType == UsmMemoryPlacement::NonUsmImported || inputType == UsmMemoryPlacement::NonUsmImported2MBAligned) {
+    if (inputType == UsmMemoryPlacement::NonUsmImportedMisaligned ||
+        inputType == UsmMemoryPlacement::NonUsmImported4KBAligned ||
+        inputType == UsmMemoryPlacement::NonUsmImported2MBAligned) {
         return true;
     }
     return false;
@@ -33,7 +37,8 @@ inline constexpr bool isUsmMemoryType(UsmMemoryPlacement inputType) {
     case UsmMemoryPlacement::Host:
     case UsmMemoryPlacement::Device:
     case UsmMemoryPlacement::Shared:
-    case UsmMemoryPlacement::NonUsmImported:
+    case UsmMemoryPlacement::NonUsmImportedMisaligned:
+    case UsmMemoryPlacement::NonUsmImported4KBAligned:
     case UsmMemoryPlacement::NonUsmImported2MBAligned:
         return true;
     default:
diff --git a/source/framework/l0/utility/usm_helper.cpp b/source/framework/l0/utility/usm_helper.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022-2024 Intel Corporation
+ * Copyright (C) 2022-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -21,27 +21,33 @@ ze_result_t allocate(UsmMemoryPlacement placement, LevelZero &levelZero, size_t
         return zeMemAllocHost(levelZero.context, &hostAllocDesc, size, 0, buffer);
     case UsmMemoryPlacement::Shared:
         return zeMemAllocShared(levelZero.context, &deviceAllocDesc, &hostAllocDesc, size, 0, levelZero.device, buffer);
-    case UsmMemoryPlacement::NonUsmImported:
-    case UsmMemoryPlacement::NonUsmImported2MBAligned: {
-        if (placement == UsmMemoryPlacement::NonUsmImported2MBAligned) {
-            *buffer = alloc2MBAligned(size);
-        } else {
-            *buffer = malloc(size);
-        }
-        return levelZero.importHostPointer.importExternalPointer(levelZero.driver, *buffer, size);
-    }
-    case UsmMemoryPlacement::NonUsm:
+    case UsmMemoryPlacement::NonUsm4KBAligned:
+        *buffer = Allocator::alloc4KBAligned(size);
+        return ZE_RESULT_SUCCESS;
     case UsmMemoryPlacement::NonUsm2MBAligned: {
-        if (placement == UsmMemoryPlacement::NonUsm2MBAligned) {
-            *buffer = alloc2MBAligned(size);
-        } else {
-            *buffer = malloc(size);
-        }
+        *buffer = Allocator::alloc2MBAligned(size);
         return ZE_RESULT_SUCCESS;
     }
+    case UsmMemoryPlacement::NonUsmMisaligned: {
+        *buffer = Allocator::allocMisaligned(size, misalignedOffset);
+        return ZE_RESULT_SUCCESS;
+    }
+    case UsmMemoryPlacement::NonUsmImportedMisaligned:
+        *buffer = Allocator::allocMisaligned(size, misalignedOffset);
+        break;
+    case UsmMemoryPlacement::NonUsmImported4KBAligned:
+        *buffer = Allocator::alloc4KBAligned(size);
+        break;
+    case UsmMemoryPlacement::NonUsmImported2MBAligned:
+        *buffer = Allocator::alloc2MBAligned(size);
+        break;
     default:
         FATAL_ERROR("Unknown placement");
     }
+    if (requiresImport(placement)) {
+        return levelZero.importHostPointer.importExternalPointer(levelZero.driver, *buffer, size);
+    }
+    return ZE_RESULT_ERROR_UNKNOWN;
 }
 
 ze_result_t allocate(UsmRuntimeMemoryPlacement runtimePlacement, LevelZero &levelZero, size_t size, void **buffer) {
@@ -78,15 +84,27 @@ ze_result_t allocate(UsmRuntimeMemoryPlacement runtimePlacement, LevelZero &leve
 }
 
 ze_result_t deallocate(UsmMemoryPlacement placement, LevelZero &levelZero, void *buffer) {
-    if (placement == UsmMemoryPlacement::NonUsm || placement == UsmMemoryPlacement::NonUsm2MBAligned) {
-        free(buffer);
-        return ZE_RESULT_SUCCESS;
-    } else if (requiresImport(placement)) {
-        auto ret = levelZero.importHostPointer.releaseExternalPointer(levelZero.driver, buffer);
-        free(buffer);
-        return ret;
-    } else {
+    ze_result_t ret = ZE_RESULT_SUCCESS;
+    if (requiresImport(placement)) {
+        ret = levelZero.importHostPointer.releaseExternalPointer(levelZero.driver, buffer);
+    }
+    switch (placement) {
+    case UsmMemoryPlacement::Device:
+    case UsmMemoryPlacement::Host:
+    case UsmMemoryPlacement::Shared:
         return zeMemFree(levelZero.context, buffer);
+    case UsmMemoryPlacement::NonUsm4KBAligned:
+    case UsmMemoryPlacement::NonUsm2MBAligned:
+    case UsmMemoryPlacement::NonUsmImported4KBAligned:
+    case UsmMemoryPlacement::NonUsmImported2MBAligned:
+        Allocator::alignedFree(buffer);
+        return ret;
+    case UsmMemoryPlacement::NonUsmMisaligned:
+    case UsmMemoryPlacement::NonUsmImportedMisaligned:
+        Allocator::misalignedFree(buffer, misalignedOffset);
+        return ret;
+    default:
+        FATAL_ERROR("Unknown placement");
     }
 }
 
diff --git a/source/framework/l0/utility/usm_helper.h b/source/framework/l0/utility/usm_helper.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 Intel Corporation
+ * Copyright (C) 2022-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -14,6 +14,8 @@
 
 namespace L0::UsmHelper {
 
+static constexpr auto misalignedOffset = 4u;
+
 ze_result_t allocate(UsmMemoryPlacement placement, LevelZero &levelZero, size_t size, void **buffer);
 
 ze_result_t allocate(UsmRuntimeMemoryPlacement runtimePlacement, LevelZero &levelZero, size_t size, void **buffer);
diff --git a/source/framework/ocl/utility/buffer_contents_helper_ocl.cpp b/source/framework/ocl/utility/buffer_contents_helper_ocl.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022-2024 Intel Corporation
+ * Copyright (C) 2022-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -31,8 +31,9 @@ cl_int BufferContentsHelperOcl::fillUsmBufferOrHostPtr(cl_command_queue queue, v
     case UsmMemoryPlacement::Host:
     case UsmMemoryPlacement::Shared:
         return fillUsmBuffer(queue, ptr, ptrSize, contents);
-    case UsmMemoryPlacement::NonUsm:
     case UsmMemoryPlacement::NonUsmMapped:
+    case UsmMemoryPlacement::NonUsmMisaligned:
+    case UsmMemoryPlacement::NonUsm4KBAligned:
     case UsmMemoryPlacement::NonUsm2MBAligned:
         fill(static_cast<uint8_t *>(ptr), ptrSize, contents);
         return CL_SUCCESS;
@@ -41,6 +42,20 @@ cl_int BufferContentsHelperOcl::fillUsmBufferOrHostPtr(cl_command_queue queue, v
     }
 }
 
+cl_int BufferContentsHelperOcl::fillUsmBufferOrHostPtr(cl_command_queue queue, void *ptr, size_t ptrSize, HostptrReuseMode reuseMode, BufferContents contents) {
+    switch (reuseMode) {
+    case HostptrReuseMode::Usm:
+        return fillUsmBuffer(queue, ptr, ptrSize, contents);
+    case HostptrReuseMode::Aligned4KB:
+    case HostptrReuseMode::Misaligned:
+    case HostptrReuseMode::Map:
+        fill(static_cast<uint8_t *>(ptr), ptrSize, contents);
+        return CL_SUCCESS;
+    default:
+        FATAL_ERROR("Unknown host ptr reuse mode");
+    }
+}
+
 cl_int BufferContentsHelperOcl::fillBufferWithRandomBytes(cl_command_queue queue, cl_mem buffer, size_t bufferSize) {
     auto cpuBuffer = std::make_unique<uint8_t[]>(bufferSize);
     BufferContentsHelper::fillWithRandomBytes(cpuBuffer.get(), bufferSize);
diff --git a/source/framework/ocl/utility/buffer_contents_helper_ocl.h b/source/framework/ocl/utility/buffer_contents_helper_ocl.h
@@ -1,12 +1,13 @@
 /*
- * Copyright (C) 2022 Intel Corporation
+ * Copyright (C) 2022-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
  */
 
 #pragma once
 
+#include "framework/enum/hostptr_reuse_mode.h"
 #include "framework/enum/usm_memory_placement.h"
 #include "framework/ocl/cl.h"
 #include "framework/utility/buffer_contents_helper.h"
@@ -15,6 +16,7 @@ class BufferContentsHelperOcl : public BufferContentsHelper {
   public:
     static cl_int fillBuffer(cl_command_queue queue, cl_mem buffer, size_t bufferSize, BufferContents contents);
     static cl_int fillUsmBufferOrHostPtr(cl_command_queue queue, void *ptr, size_t ptrSize, UsmMemoryPlacement placement, BufferContents contents);
+    static cl_int fillUsmBufferOrHostPtr(cl_command_queue queue, void *ptr, size_t ptrSize, HostptrReuseMode reuseMode, BufferContents contents);
 
   private:
     static cl_int fillBufferWithRandomBytes(cl_command_queue queue, cl_mem buffer, size_t bufferSize);
diff --git a/source/framework/ocl/utility/hostptr_reuse_helper.cpp b/source/framework/ocl/utility/hostptr_reuse_helper.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022-2023 Intel Corporation
+ * Copyright (C) 2022-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -8,6 +8,7 @@
 #include "framework/ocl/utility/hostptr_reuse_helper.h"
 
 #include "framework/ocl/utility/error.h"
+#include "framework/utility/aligned_allocator.h"
 
 cl_int HostptrReuseHelper::allocateBufferHostptr(Opencl &opencl,
                                                  HostptrReuseMode reuseMode,
@@ -19,8 +20,11 @@ cl_int HostptrReuseHelper::allocateBufferHostptr(Opencl &opencl,
 
     cl_int retVal{};
     switch (reuseMode) {
-    case HostptrReuseMode::None:
-        outAlloc.ptr = new uint8_t[size];
+    case HostptrReuseMode::Aligned4KB:
+        outAlloc.ptr = Allocator::alloc4KBAligned(size);
+        break;
+    case HostptrReuseMode::Misaligned:
+        outAlloc.ptr = Allocator::allocMisaligned(size, misalignedOffset);
         break;
     case HostptrReuseMode::Usm: {
         const auto usmFunctions = opencl.getExtensions().queryUsmFunctions();
@@ -48,8 +52,11 @@ cl_int HostptrReuseHelper::allocateBufferHostptr(Opencl &opencl,
 
 cl_int HostptrReuseHelper::deallocateBufferHostptr(Alloc alloc) {
     switch (alloc.reuseMode) {
-    case HostptrReuseMode::None:
-        delete[] (static_cast<uint8_t *>(alloc.ptr));
+    case HostptrReuseMode::Aligned4KB:
+        Allocator::alignedFree(alloc.ptr);
+        break;
+    case HostptrReuseMode::Misaligned:
+        Allocator::misalignedFree(alloc.ptr, misalignedOffset);
         break;
     case HostptrReuseMode::Usm:
         CL_SUCCESS_OR_RETURN(alloc.clMemFreeINTEL(alloc.context, alloc.ptr));
diff --git a/source/framework/ocl/utility/hostptr_reuse_helper.h b/source/framework/ocl/utility/hostptr_reuse_helper.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 Intel Corporation
+ * Copyright (C) 2022-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -13,6 +13,8 @@
 #include "framework/test_case/test_result.h"
 
 struct HostptrReuseHelper {
+    static constexpr size_t misalignedOffset = 4u;
+
     struct Alloc {
         void *ptr = nullptr;
 
diff --git a/source/framework/ocl/utility/usm_helper_ocl.cpp b/source/framework/ocl/utility/usm_helper_ocl.cpp
diff --git a/source/framework/ocl/utility/usm_helper_ocl.h b/source/framework/ocl/utility/usm_helper_ocl.h
diff --git a/source/framework/utility/aligned_allocator.h b/source/framework/utility/aligned_allocator.h
diff --git a/source/framework/utility/linux/aligned_allocator.cpp b/source/framework/utility/linux/aligned_allocator.cpp
diff --git a/source/framework/utility/windows/aligned_allocator.cpp b/source/framework/utility/windows/aligned_allocator.cpp

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`/*`
`2`		`- * Copyright (C) 2022 Intel Corporation`
	`2`	`+ * Copyright (C) 2022-2025 Intel Corporation`
`3`	`3`	`*`
`4`	`4`	`* SPDX-License-Identifier: MIT`
`5`	`5`	`*`
`@@ -14,6 +14,8 @@`
`14`	`14`
`15`	`15`	`namespace L0::UsmHelper {`
`16`	`16`
	`17`	`+static constexpr auto misalignedOffset = 4u;`
	`18`	`+`
`17`	`19`	`ze_result_t allocate(UsmMemoryPlacement placement, LevelZero &levelZero, size_t size, void **buffer);`
`18`	`20`
`19`	`21`	`ze_result_t allocate(UsmRuntimeMemoryPlacement runtimePlacement, LevelZero &levelZero, size_t size, void **buffer);`