fix: allowing neo ULT build with optimization enabled 5/n

oskarweb · Compute-Runtime-Automation · commit 1c1b2db9a902 · 2024-12-23T13:07:55.000+01:00
- fix mismatched-new-delete warnings
- fix initialization warnings
- fix attempt to free a non-heap object warnings

Related-To: NEO-8116

Signed-off-by: Oskar Hubert Weber &lt;oskar.hubert.weber@intel.com&gt;
diff --git a/level_zero/core/test/unit_tests/sources/rtas/test_rtas.cpp b/level_zero/core/test/unit_tests/sources/rtas/test_rtas.cpp
@@ -349,11 +349,10 @@ TEST_F(RTASTest, GivenUnderlyingBuilderDestroySucceedsThenSuccessIsReturned) {
 }
 
 TEST_F(RTASTest, GivenUnderlyingBuilderDestroyFailsThenErrorIsReturned) {
-    RTASBuilder pRTASBuilder;
+    auto pRTASBuilder = std::make_unique<RTASBuilder>();
     builderDestroyExpImpl = &builderDestroyFail;
-    driverHandle->rtasLibraryHandle = std::make_unique<MockRTASOsLibrary>();
 
-    EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, L0::zeRTASBuilderDestroyExp(pRTASBuilder.toHandle()));
+    EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, L0::zeRTASBuilderDestroyExp(pRTASBuilder.get()));
     EXPECT_EQ(1u, builderDestroyFailCalled);
 }
 
@@ -454,10 +453,10 @@ TEST_F(RTASTest, GivenUnderlyingParallelOperationDestroySucceedsThenSuccessIsRet
 }
 
 TEST_F(RTASTest, GivenUnderlyingParallelOperationDestroyFailsThenErrorIsReturned) {
-    RTASParallelOperation pParallelOperation;
+    auto pParallelOperation = std::make_unique<RTASParallelOperation>();
     parallelOperationDestroyExpImpl = &parallelOperationDestroyFail;
 
-    EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, L0::zeRTASParallelOperationDestroyExp(pParallelOperation.toHandle()));
+    EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, L0::zeRTASParallelOperationDestroyExp(pParallelOperation.get()));
     EXPECT_EQ(1u, parallelOperationDestroyFailCalled);
 }
 
diff --git a/opencl/test/black_box_test/hello_world_opencl.cpp b/opencl/test/black_box_test/hello_world_opencl.cpp
@@ -19,7 +19,7 @@ int main(int argc, char **argv) {
     int retVal = 0;
     const char *fileName = "kernelOutput.txt";
     cl_int err = 0;
-    unique_ptr<cl_platform_id> platforms;
+    unique_ptr<cl_platform_id[]> platforms;
     cl_device_id device_id = 0;
     cl_uint platformsCount = 0;
     cl_context context = NULL;
diff --git a/opencl/test/black_box_test/hello_world_opencl_tracing.cpp b/opencl/test/black_box_test/hello_world_opencl_tracing.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Intel Corporation
+ * Copyright (C) 2023-2024 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -65,7 +65,7 @@ bool validateOutput(const std::stringstream &out) {
 }
 
 int main(int argc, char **argv) {
-    std::unique_ptr<cl_platform_id> platforms;
+    std::unique_ptr<cl_platform_id[]> platforms;
     cl_device_id deviceId = 0;
     cl_uint platformsCount = 0;
     cl_context context = nullptr;
diff --git a/opencl/test/unit_test/memory_manager/cl_memory_manager_tests.cpp b/opencl/test/unit_test/memory_manager/cl_memory_manager_tests.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2018-2023 Intel Corporation
+ * Copyright (C) 2018-2024 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -207,7 +207,7 @@ TEST(ClMemoryManagerTest, givenAllowedTilingWhenIsCopyRequiredIsCalledThenTrueIs
     imgInfo.slicePitch = imgInfo.rowPitch * imageDesc.image_height;
     imgInfo.size = imgInfo.slicePitch;
 
-    char memory;
+    char memory{};
 
     EXPECT_TRUE(MockMemoryManager::isCopyRequired(imgInfo, &memory));
 }
@@ -233,7 +233,7 @@ TEST(ClMemoryManagerTest, givenDifferentRowPitchWhenIsCopyRequiredIsCalledThenTr
     imgInfo.slicePitch = imgInfo.rowPitch * imageDesc.image_height;
     imgInfo.size = imgInfo.slicePitch;
 
-    char memory[10];
+    char memory[10] = {};
 
     EXPECT_TRUE(MockMemoryManager::isCopyRequired(imgInfo, memory));
 }
@@ -259,7 +259,7 @@ TEST(ClMemoryManagerTest, givenDifferentSlicePitchAndTilingNotAllowedWhenIsCopyR
     imgInfo.rowPitch = imageDesc.image_width * surfaceFormat->surfaceFormat.imageElementSizeInBytes;
     imgInfo.slicePitch = imgInfo.rowPitch * imageDesc.image_height;
     imgInfo.size = imgInfo.slicePitch;
-    char memory[8];
+    char memory[8] = {};
 
     EXPECT_TRUE(MockMemoryManager::isCopyRequired(imgInfo, memory));
 }
@@ -284,7 +284,7 @@ TEST(ClMemoryManagerTest, givenNotCachelinAlignedPointerWhenIsCopyRequiredIsCall
     imgInfo.rowPitch = imageDesc.image_width * surfaceFormat->surfaceFormat.imageElementSizeInBytes;
     imgInfo.slicePitch = imgInfo.rowPitch * imageDesc.image_height;
     imgInfo.size = imgInfo.slicePitch;
-    char memory[8];
+    char memory[8] = {};
 
     EXPECT_TRUE(MockMemoryManager::isCopyRequired(imgInfo, &memory[1]));
 }
diff --git a/shared/source/compiler_interface/linux/os_compiler_cache_helper.cpp b/shared/source/compiler_interface/linux/os_compiler_cache_helper.cpp
@@ -67,15 +67,19 @@ bool checkDefaultCacheDirSettings(std::string &cacheDir, NEO::EnvironmentVariabl
 }
 
 time_t getFileModificationTime(const std::string &path) {
-    struct stat st;
+    struct stat st {
+        0, 0
+    };
     if (NEO::SysCalls::stat(path, &st) == 0) {
         return st.st_mtime;
     }
     return 0;
 }
 
 size_t getFileSize(const std::string &path) {
-    struct stat st;
+    struct stat st {
+        0, 0
+    };
     if (NEO::SysCalls::stat(path, &st) == 0) {
         return static_cast<size_t>(st.st_size);
     }
diff --git a/shared/source/os_interface/linux/os_time_linux.cpp b/shared/source/os_interface/linux/os_time_linux.cpp
@@ -29,7 +29,9 @@ OSTimeLinux::OSTimeLinux(OSInterface &osInterface, std::unique_ptr<DeviceTime> d
 }
 
 bool OSTimeLinux::getCpuTime(uint64_t *timestamp) {
-    struct timespec ts;
+    struct timespec ts {
+        0, 0
+    };
 
     if (getTimeFunc(CLOCK_MONOTONIC_RAW, &ts)) {
         return false;
@@ -41,7 +43,9 @@ bool OSTimeLinux::getCpuTime(uint64_t *timestamp) {
 }
 
 bool OSTime::getCpuTimeHost(uint64_t *timestamp) {
-    struct timespec ts;
+    struct timespec ts {
+        0, 0
+    };
 
     auto ret = clock_gettime(CLOCK_MONOTONIC_RAW, &ts);
 
@@ -51,7 +55,9 @@ bool OSTime::getCpuTimeHost(uint64_t *timestamp) {
 }
 
 double OSTimeLinux::getHostTimerResolution() const {
-    struct timespec ts;
+    struct timespec ts {
+        0, 0
+    };
     if (resolutionFunc(CLOCK_MONOTONIC_RAW, &ts)) {
         return 0;
     }
diff --git a/shared/test/unit_test/helpers/bindless_heaps_helper_tests.cpp b/shared/test/unit_test/helpers/bindless_heaps_helper_tests.cpp
@@ -634,7 +634,7 @@ TEST_F(BindlessHeapsHelperTests, givenLocalMemorySupportWhenReservingMemoryForSp
         size_t reservationSize = MemoryConstants::pageSize64k;
         size_t alignment = MemoryConstants::pageSize64k;
 
-        memManager->localMemorySupported = {localMemSupported};
+        memManager->localMemorySupported = std::vector<bool>{localMemSupported};
 
         auto specialSshReservationSuccessful = bindlessHeapHelper->tryReservingMemoryForSpecialSsh(reservationSize, alignment);
         EXPECT_TRUE(specialSshReservationSuccessful);
diff --git a/shared/test/unit_test/os_interface/linux/drm_memory_manager_tests.cpp b/shared/test/unit_test/os_interface/linux/drm_memory_manager_tests.cpp
@@ -5243,8 +5243,17 @@ TEST_F(DrmMemoryManagerTest, whenDebugFlagToNotFreeResourcesIsSpecifiedThenFreeI
     TestedDrmMemoryManager memoryManager(false, false, false, *executionEnvironment);
     size_t sizeIn = 1024llu;
     uint64_t gpuAddress = 0x1337llu;
-    DrmAllocation stackDrmAllocation(0u, 1u /*num gmms*/, AllocationType::buffer, nullptr, nullptr, gpuAddress, sizeIn, MemoryPool::system64KBPages);
-    memoryManager.freeGraphicsMemoryImpl(&stackDrmAllocation);
+    auto drmAllocation = std::make_unique<DrmAllocation>(0u, 1u /*num gmms*/, AllocationType::buffer, nullptr, nullptr, gpuAddress, sizeIn, MemoryPool::system64KBPages);
+    memoryManager.freeGraphicsMemoryImpl(drmAllocation.get());
+
+    EXPECT_EQ(drmAllocation->getNumGmms(), 1u);
+    EXPECT_EQ(drmAllocation->getRootDeviceIndex(), 0u);
+    EXPECT_EQ(drmAllocation->getBOs().size(), EngineLimits::maxHandleCount);
+    EXPECT_EQ(drmAllocation->getAllocationType(), AllocationType::buffer);
+    EXPECT_EQ(drmAllocation->getGpuAddress(), gpuAddress);
+    EXPECT_EQ(drmAllocation->getUnderlyingBufferSize(), sizeIn);
+    EXPECT_EQ(drmAllocation->getMemoryPool(), MemoryPool::system64KBPages);
+    EXPECT_EQ(drmAllocation->getUnderlyingBuffer(), nullptr);
 }
 
 TEST_F(DrmMemoryManagerTest, given2MbPagesDisabledWhenWddmMemoryManagerIsCreatedThenAlignmentSelectorHasExpectedAlignments) {

Original file line number	Diff line number	Diff line change
`@@ -349,11 +349,10 @@ TEST_F(RTASTest, GivenUnderlyingBuilderDestroySucceedsThenSuccessIsReturned) {`
`349`	`349`	`}`
`350`	`350`
`351`	`351`	`TEST_F(RTASTest, GivenUnderlyingBuilderDestroyFailsThenErrorIsReturned) {`
`352`		`- RTASBuilder pRTASBuilder;`
	`352`	`+ auto pRTASBuilder = std::make_unique<RTASBuilder>();`
`353`	`353`	`builderDestroyExpImpl = &builderDestroyFail;`
`354`		`- driverHandle->rtasLibraryHandle = std::make_unique<MockRTASOsLibrary>();`
`355`	`354`
`356`		`- EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, L0::zeRTASBuilderDestroyExp(pRTASBuilder.toHandle()));`
	`355`	`+ EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, L0::zeRTASBuilderDestroyExp(pRTASBuilder.get()));`
`357`	`356`	`EXPECT_EQ(1u, builderDestroyFailCalled);`
`358`	`357`	`}`
`359`	`358`
`@@ -454,10 +453,10 @@ TEST_F(RTASTest, GivenUnderlyingParallelOperationDestroySucceedsThenSuccessIsRet`
`454`	`453`	`}`
`455`	`454`
`456`	`455`	`TEST_F(RTASTest, GivenUnderlyingParallelOperationDestroyFailsThenErrorIsReturned) {`
`457`		`- RTASParallelOperation pParallelOperation;`
	`456`	`+ auto pParallelOperation = std::make_unique<RTASParallelOperation>();`
`458`	`457`	`parallelOperationDestroyExpImpl = &parallelOperationDestroyFail;`
`459`	`458`
`460`		`- EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, L0::zeRTASParallelOperationDestroyExp(pParallelOperation.toHandle()));`
	`459`	`+ EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, L0::zeRTASParallelOperationDestroyExp(pParallelOperation.get()));`
`461`	`460`	`EXPECT_EQ(1u, parallelOperationDestroyFailCalled);`
`462`	`461`	`}`
`463`	`462`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`/*`
`2`		`- * Copyright (C) 2023 Intel Corporation`
	`2`	`+ * Copyright (C) 2023-2024 Intel Corporation`
`3`	`3`	`*`
`4`	`4`	`* SPDX-License-Identifier: MIT`
`5`	`5`	`*`
`@@ -65,7 +65,7 @@ bool validateOutput(const std::stringstream &out) {`
`65`	`65`	`}`
`66`	`66`
`67`	`67`	`int main(int argc, char **argv) {`
`68`		`- std::unique_ptr<cl_platform_id> platforms;`
	`68`	`+ std::unique_ptr<cl_platform_id[]> platforms;`
`69`	`69`	`cl_device_id deviceId = 0;`
`70`	`70`	`cl_uint platformsCount = 0;`
`71`	`71`	`cl_context context = nullptr;`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`/*`
`2`		`- * Copyright (C) 2018-2023 Intel Corporation`
	`2`	`+ * Copyright (C) 2018-2024 Intel Corporation`
`3`	`3`	`*`
`4`	`4`	`* SPDX-License-Identifier: MIT`
`5`	`5`	`*`
`@@ -207,7 +207,7 @@ TEST(ClMemoryManagerTest, givenAllowedTilingWhenIsCopyRequiredIsCalledThenTrueIs`
`207`	`207`	`imgInfo.slicePitch = imgInfo.rowPitch * imageDesc.image_height;`
`208`	`208`	`imgInfo.size = imgInfo.slicePitch;`
`209`	`209`
`210`		`- char memory;`
	`210`	`+ char memory{};`
`211`	`211`
`212`	`212`	`EXPECT_TRUE(MockMemoryManager::isCopyRequired(imgInfo, &memory));`
`213`	`213`	`}`
`@@ -233,7 +233,7 @@ TEST(ClMemoryManagerTest, givenDifferentRowPitchWhenIsCopyRequiredIsCalledThenTr`
`233`	`233`	`imgInfo.slicePitch = imgInfo.rowPitch * imageDesc.image_height;`
`234`	`234`	`imgInfo.size = imgInfo.slicePitch;`
`235`	`235`
`236`		`- char memory[10];`
	`236`	`+ char memory[10] = {};`
`237`	`237`
`238`	`238`	`EXPECT_TRUE(MockMemoryManager::isCopyRequired(imgInfo, memory));`
`239`	`239`	`}`
`@@ -259,7 +259,7 @@ TEST(ClMemoryManagerTest, givenDifferentSlicePitchAndTilingNotAllowedWhenIsCopyR`
`259`	`259`	`imgInfo.rowPitch = imageDesc.image_width * surfaceFormat->surfaceFormat.imageElementSizeInBytes;`
`260`	`260`	`imgInfo.slicePitch = imgInfo.rowPitch * imageDesc.image_height;`
`261`	`261`	`imgInfo.size = imgInfo.slicePitch;`
`262`		`- char memory[8];`
	`262`	`+ char memory[8] = {};`
`263`	`263`
`264`	`264`	`EXPECT_TRUE(MockMemoryManager::isCopyRequired(imgInfo, memory));`
`265`	`265`	`}`
`@@ -284,7 +284,7 @@ TEST(ClMemoryManagerTest, givenNotCachelinAlignedPointerWhenIsCopyRequiredIsCall`
`284`	`284`	`imgInfo.rowPitch = imageDesc.image_width * surfaceFormat->surfaceFormat.imageElementSizeInBytes;`
`285`	`285`	`imgInfo.slicePitch = imgInfo.rowPitch * imageDesc.image_height;`
`286`	`286`	`imgInfo.size = imgInfo.slicePitch;`
`287`		`- char memory[8];`
	`287`	`+ char memory[8] = {};`
`288`	`288`
`289`	`289`	`EXPECT_TRUE(MockMemoryManager::isCopyRequired(imgInfo, &memory[1]));`
`290`	`290`	`}`
Original file line number	Diff line number	Diff line change
`@@ -67,15 +67,19 @@ bool checkDefaultCacheDirSettings(std::string &cacheDir, NEO::EnvironmentVariabl`
`67`	`67`	`}`
`68`	`68`
`69`	`69`	`time_t getFileModificationTime(const std::string &path) {`
`70`		`- struct stat st;`
	`70`	`+ struct stat st {`
	`71`	`+ 0, 0`
	`72`	`+ };`
`71`	`73`	`if (NEO::SysCalls::stat(path, &st) == 0) {`
`72`	`74`	`return st.st_mtime;`
`73`	`75`	`}`
`74`	`76`	`return 0;`
`75`	`77`	`}`
`76`	`78`
`77`	`79`	`size_t getFileSize(const std::string &path) {`
`78`		`- struct stat st;`
	`80`	`+ struct stat st {`
	`81`	`+ 0, 0`
	`82`	`+ };`
`79`	`83`	`if (NEO::SysCalls::stat(path, &st) == 0) {`
`80`	`84`	`return static_cast<size_t>(st.st_size);`
`81`	`85`	`}`