Add missing lock in MapOperationsHandler

Signed-off-by: Bartosz Dunajski <[email protected]>

Author: BartoszDunajski

opencl/source/mem_obj/map_operations_handler.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2018-2021 Intel Corporation
+ * Copyright (C) 2018-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -62,6 +62,8 @@ bool MapOperationsHandler::find(void *mappedPtr, MapInfo &outMapInfo) {
 }
 
 bool NEO::MapOperationsHandler::findInfoForHostPtr(const void *ptr, size_t size, MapInfo &outMapInfo) {
+    std::lock_guard<std::mutex> lock(mtx);
+
     for (auto &mapInfo : mappedPointers) {
         void *ptrStart = mapInfo.ptr;
         void *ptrEnd = ptrOffset(mapInfo.ptr, mapInfo.ptrLength);

opencl/test/unit_test/mt_tests/helpers/CMakeLists.txt

@@ -1,13 +1,14 @@
 #
-# Copyright (C) 2018-2021 Intel Corporation
+# Copyright (C) 2018-2022 Intel Corporation
 #
 # SPDX-License-Identifier: MIT
 #
 
 set(IGDRCL_SRCS_mt_tests_helpers
     # local files
     ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
-    ${CMAKE_CURRENT_SOURCE_DIR}/interlocked_max_mt_tests.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/base_object_tests_mt.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/interlocked_max_mt_tests.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/map_operations_handler_mt_tests.cpp
 )
 target_sources(igdrcl_mt_tests PRIVATE ${IGDRCL_SRCS_mt_tests_helpers})

opencl/test/unit_test/mt_tests/helpers/map_operations_handler_mt_tests.cpp

@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2018-2022 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "shared/test/common/mocks/mock_graphics_allocation.h"
+
+#include "opencl/source/mem_obj/map_operations_handler.h"
+
+#include "gtest/gtest.h"
+
+#include <vector>
+
+namespace NEO {
+
+struct MockMapOperationsHandler : public MapOperationsHandler {
+    using MapOperationsHandler::isOverlapping;
+    using MapOperationsHandler::mappedPointers;
+};
+
+struct MapOperationsHandlerMtTests : public ::testing::Test {
+    MockMapOperationsHandler mockHandler;
+    MockGraphicsAllocation mockAllocation;
+    std::vector<void *> mappedPtrs;
+
+    void SetUp() override {
+        MemObjSizeArray size = {{10, 10, 10}};
+        MemObjOffsetArray offset = {{0, 0, 0}};
+        cl_map_flags mapFlags = CL_MAP_READ;
+
+        for (size_t i = 1; i <= 10; i++) {
+            auto ptr = reinterpret_cast<void *>(0x1000lu * i);
+
+            mappedPtrs.push_back(ptr);
+            EXPECT_TRUE(mockHandler.add(ptr, 10, mapFlags, size, offset, 0, &mockAllocation));
+        }
+    }
+};
+
+TEST_F(MapOperationsHandlerMtTests, giveMapOperationsHandlerWhenAddingFindingAndRemovingThenExecuteSafely) {
+    std::atomic<bool> removed = false;
+    std::atomic<bool> t1Started = false;
+    std::atomic<bool> t2Started = false;
+    std::atomic<bool> t3Started = false;
+
+    auto find = [&](std::atomic<bool> *threadStarted) {
+        while (!removed.load()) {
+            for (auto &ptr : mappedPtrs) {
+                MapInfo out;
+                mockHandler.findInfoForHostPtr(ptr, 1, out);
+            }
+
+            threadStarted->store(true);
+            std::this_thread::yield();
+        }
+    };
+
+    auto remove = [&]() {
+        while (!t1Started.load() || !t2Started.load() || !t3Started.load()) {
+            std::this_thread::yield();
+        }
+
+        for (auto &ptr : mappedPtrs) {
+            mockHandler.remove(ptr);
+        }
+
+        removed.store(true);
+    };
+
+    std::thread t1(find, &t1Started);
+    std::thread t2(find, &t2Started);
+    std::thread t3(find, &t3Started);
+    std::thread t4(remove);
+
+    t1.join();
+    t2.join();
+    t3.join();
+    t4.join();
+}
+} // namespace NEO