Create L0 debugger object

Related-To: NEO-4713

Change-Id: I9d10019bbe6e8514ce10bdd729a64ea233bf91b0
Signed-off-by: Mateusz Hoppe <mateusz.hoppe@intel.com>

level_zero/CMakeLists.txt

@@ -322,6 +322,15 @@ function(generate_l0_lib LIB_NAME MOCKABLE)
         L0_SRCS_DEBUGGER
         L0_SRCS_OCLOC_SHARED
     )
+    if(WIN32)
+      append_sources_from_properties(L0_RUNTIME_SOURCES
+        L0_SRCS_DEBUGGER_WINDOWS
+      )
+    else()
+      append_sources_from_properties(L0_RUNTIME_SOURCES
+        L0_SRCS_DEBUGGER_LINUX
+      )
+    endif()
 
     target_sources(${LIB_NAME} PRIVATE ${L0_RUNTIME_SOURCES})
 

level_zero/core/source/debugger/CMakeLists.txt

@@ -10,4 +10,5 @@ set(L0_SRCS_DEBUGGER
   ${CMAKE_CURRENT_SOURCE_DIR}/debugger_l0.h
 )
 
-set_property(GLOBAL PROPERTY L0_SRCS_DEBUGGER ${L0_SRCS_DEBUGGER})
+add_subdirectories()
+set_property(GLOBAL PROPERTY L0_SRCS_DEBUGGER ${L0_SRCS_DEBUGGER})

level_zero/core/source/debugger/debugger_l0.h

@@ -6,13 +6,27 @@
  */
 
 #pragma once
-
 #include "shared/source/debugger/debugger.h"
+#include "shared/source/helpers/non_copyable_or_moveable.h"
+
+#include <memory>
+
+namespace NEO {
+class Device;
+}
 
 namespace L0 {
-class DebuggerL0 : public NEO::Debugger {
+class DebuggerL0 : public NEO::Debugger, NEO::NonCopyableOrMovableClass {
   public:
+    static std::unique_ptr<Debugger> create(NEO::Device *device);
     bool isDebuggerActive() override;
+
+    DebuggerL0(NEO::Device *device) : device(device) {
+        isLegacyMode = false;
+    }
     ~DebuggerL0() override = default;
+
+  protected:
+    NEO::Device *device = nullptr;
 };
 } // namespace L0

level_zero/core/source/debugger/linux/CMakeLists.txt

@@ -0,0 +1,13 @@
+#
+# Copyright (C) 2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+#
+
+set(L0_SRCS_DEBUGGER_LINUX
+  ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+  ${CMAKE_CURRENT_SOURCE_DIR}/debugger_l0_linux.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/debugger_l0_linux.h
+)
+
+set_property(GLOBAL PROPERTY L0_SRCS_DEBUGGER_LINUX ${L0_SRCS_DEBUGGER_LINUX})

level_zero/core/source/debugger/linux/debugger_l0_linux.cpp

@@ -0,0 +1,15 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "level_zero/core/source/debugger/linux/debugger_l0_linux.h"
+
+namespace L0 {
+std::unique_ptr<NEO::Debugger> DebuggerL0::create(NEO::Device *device) {
+    return std::make_unique<DebuggerL0Linux>(device);
+}
+
+} // namespace L0

level_zero/core/source/debugger/linux/debugger_l0_linux.h

@@ -0,0 +1,18 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+#include "level_zero/core/source/debugger/debugger_l0.h"
+
+namespace L0 {
+class DebuggerL0Linux : public DebuggerL0 {
+  public:
+    DebuggerL0Linux(NEO::Device *device) : DebuggerL0(device) {
+    }
+    ~DebuggerL0Linux() override = default;
+};
+} // namespace L0

level_zero/core/source/debugger/windows/CMakeLists.txt

@@ -0,0 +1,14 @@
+#
+# Copyright (C) 2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+#
+
+set(L0_SRCS_DEBUGGER_WINDOWS
+  ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+  ${CMAKE_CURRENT_SOURCE_DIR}/debugger_l0_windows.cpp
+)
+
+if(WIN32)
+  set_property(GLOBAL PROPERTY L0_SRCS_DEBUGGER_WINDOWS ${L0_SRCS_DEBUGGER_WINDOWS})
+endif()

level_zero/core/source/debugger/windows/debugger_l0_windows.cpp

@@ -0,0 +1,14 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "level_zero/core/source/debugger/debugger_l0.h"
+
+namespace L0 {
+std::unique_ptr<NEO::Debugger> DebuggerL0::create(NEO::Device *device) {
+    return std::unique_ptr<NEO::Debugger>(nullptr);
+}
+} // namespace L0

level_zero/core/source/device/device.h

@@ -106,10 +106,8 @@ struct Device : _ze_device_handle_t {
     virtual NEO::PreemptionMode getDevicePreemptionMode() const = 0;
     virtual const NEO::DeviceInfo &getDeviceInfo() const = 0;
     virtual NEO::Device *getNEODevice() = 0;
+    NEO::SourceLevelDebugger *getSourceLevelDebugger() { return getNEODevice()->getSourceLevelDebugger(); }
 
-    NEO::SourceLevelDebugger *getSourceLevelDebugger() {
-        return getNEODevice() ? reinterpret_cast<NEO::SourceLevelDebugger *>(getNEODevice()->getDebugger()) : nullptr;
-    }
     virtual NEO::GraphicsAllocation *getDebugSurface() const = 0;
 
     virtual NEO::GraphicsAllocation *allocateManagedMemoryFromHostPtr(void *buffer,

level_zero/core/source/driver/driver_handle_imp.cpp

@@ -13,6 +13,7 @@
 #include "shared/source/os_interface/debug_env_reader.h"
 #include "shared/source/os_interface/os_library.h"
 
+#include "level_zero/core/source/debugger/debugger_l0.h"
 #include "level_zero/core/source/device/device_imp.h"
 
 #include "driver_version_l0.h"
@@ -108,6 +109,10 @@ ze_result_t DriverHandleImp::getMemAllocProperties(const void *ptr,
 
 DriverHandleImp::~DriverHandleImp() {
     for (auto &device : this->devices) {
+        if (device->getNEODevice()->getExecutionEnvironment()->rootDeviceEnvironments[device->getRootDeviceIndex()]->debugger.get() &&
+            !device->getNEODevice()->getExecutionEnvironment()->rootDeviceEnvironments[device->getRootDeviceIndex()]->debugger->isLegacy()) {
+            device->getNEODevice()->getExecutionEnvironment()->rootDeviceEnvironments[device->getRootDeviceIndex()]->debugger.reset(nullptr);
+        }
         delete device;
     }
     if (this->svmAllocsManager) {
@@ -149,6 +154,11 @@ ze_result_t DriverHandleImp::initialize(std::vector<std::unique_ptr<NEO::Device>
             }
         }
 
+        if (enableProgramDebugging) {
+            UNRECOVERABLE_IF(neoDevice->getDebugger() != nullptr && enableProgramDebugging);
+            neoDevice->getExecutionEnvironment()->rootDeviceEnvironments[neoDevice->getRootDeviceIndex()]->debugger = DebuggerL0::create(neoDevice.get());
+        }
+
         auto device = Device::create(this, neoDevice.release(), currentDeviceMask, false);
         this->devices.push_back(device);
     }

level_zero/core/test/unit_tests/mocks/CMakeLists.txt

@@ -24,6 +24,7 @@ set(L0_MOCKS_SOURCES
     ${CMAKE_CURRENT_SOURCE_DIR}/mock_event.h
     ${CMAKE_CURRENT_SOURCE_DIR}/mock_gmm_resource_info_l0.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/mock_kernel.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/mock_l0_debugger.h
     ${CMAKE_CURRENT_SOURCE_DIR}/mock_memory_manager.h
     ${CMAKE_CURRENT_SOURCE_DIR}/mock_memory_manager.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/mock_module.cpp

level_zero/core/test/unit_tests/mocks/mock_l0_debugger.h

@@ -0,0 +1,21 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+#include "level_zero/core/source/debugger/debugger_l0.h"
+
+namespace L0 {
+namespace ult {
+
+class MockDebuggerL0 : public L0::DebuggerL0 {
+  public:
+    using L0::DebuggerL0::DebuggerL0;
+    ~MockDebuggerL0() override = default;
+};
+
+} // namespace ult
+} // namespace L0

level_zero/core/test/unit_tests/sources/debugger/CMakeLists.txt

@@ -7,6 +7,10 @@
 target_sources(${TARGET_NAME} PRIVATE
     ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
     ${CMAKE_CURRENT_SOURCE_DIR}/active_debugger_fixture.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/test_debugger.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/l0_debugger_fixture.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/test_source_level_debugger.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/test_l0_debugger.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/test_module_with_debug.cpp
-)
+)
+
+add_subdirectories()

level_zero/core/test/unit_tests/sources/debugger/l0_debugger_fixture.h

@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "shared/test/unit_test/helpers/debug_manager_state_restore.h"
+#include "shared/test/unit_test/mocks/mock_device.h"
+
+#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
+#include "level_zero/core/test/unit_tests/mocks/mock_l0_debugger.h"
+
+namespace L0 {
+namespace ult {
+
+struct L0DebuggerFixture {
+    void SetUp() {
+        neoDevice = NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(NEO::defaultHwInfo.get());
+        NEO::DeviceVector devices;
+        devices.push_back(std::unique_ptr<NEO::Device>(neoDevice));
+        driverHandle = std::make_unique<Mock<L0::DriverHandleImp>>();
+        driverHandle->enableProgramDebugging = true;
+
+        driverHandle->initialize(std::move(devices));
+        device = driverHandle->devices[0];
+    }
+
+    void TearDown() {
+    }
+
+    std::unique_ptr<Mock<L0::DriverHandleImp>> driverHandle;
+    NEO::MockDevice *neoDevice = nullptr;
+    L0::Device *device = nullptr;
+};
+
+struct MockL0DebuggerFixture : public L0DebuggerFixture {
+    void SetUp() {
+        L0DebuggerFixture::SetUp();
+        neoDevice->getExecutionEnvironment()->rootDeviceEnvironments[neoDevice->getRootDeviceIndex()]->debugger.reset(new MockDebuggerL0(neoDevice));
+    }
+
+    void TearDown() {
+        L0DebuggerFixture::TearDown();
+    }
+};
+
+} // namespace ult
+} // namespace L0

level_zero/core/test/unit_tests/sources/debugger/linux/CMakeLists.txt

@@ -0,0 +1,12 @@
+#
+# Copyright (C) 2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+#
+
+if(UNIX)
+target_sources(${TARGET_NAME} PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+    ${CMAKE_CURRENT_SOURCE_DIR}/test_l0_debugger_linux.cpp
+)
+endif()

level_zero/core/test/unit_tests/sources/debugger/linux/test_l0_debugger_linux.cpp

@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "test.h"
+
+#include "level_zero/core/test/unit_tests/sources/debugger/l0_debugger_fixture.h"
+
+namespace L0 {
+namespace ult {
+
+using L0DebuggerLinuxTest = Test<L0DebuggerFixture>;
+
+TEST_F(L0DebuggerLinuxTest, givenProgramDebuggingEnabledWhenDriverHandleIsCreatedThenItAllocatesL0Debugger) {
+    EXPECT_NE(nullptr, neoDevice->getDebugger());
+    EXPECT_FALSE(neoDevice->getDebugger()->isLegacy());
+
+    EXPECT_EQ(nullptr, neoDevice->getSourceLevelDebugger());
+}
+
+} // namespace ult
+} // namespace L0

level_zero/core/test/unit_tests/sources/debugger/test_l0_debugger.cpp

@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "test.h"
+
+#include "level_zero/core/test/unit_tests/sources/debugger/l0_debugger_fixture.h"
+
+namespace L0 {
+namespace ult {
+
+using L0DebuggerTest = Test<MockL0DebuggerFixture>;
+
+TEST_F(L0DebuggerTest, givenL0DebuggerWhenCallingIsLegacyThenFalseIsReturned) {
+    EXPECT_FALSE(neoDevice->getDebugger()->isLegacy());
+}
+
+TEST_F(L0DebuggerTest, givenL0DebuggerWhenGettingSourceLevelDebuggerThenNullptrReturned) {
+    EXPECT_EQ(nullptr, neoDevice->getSourceLevelDebugger());
+}
+
+TEST_F(L0DebuggerTest, givenL0DebuggerWhenCallingIsDebuggerActiveThenFalseIsReturned) {
+    EXPECT_FALSE(neoDevice->getDebugger()->isDebuggerActive());
+}
+
+} // namespace ult
+} // namespace L0

level_zero/core/test/unit_tests/sources/device/test_device.cpp

@@ -488,5 +488,9 @@ TEST_F(DeviceTest, givenBlitterSupportAndCopyOnlyFlagWhenCopyOnlyDebugFlagIsSetT
     EXPECT_EQ(ZE_RESULT_SUCCESS, res);
 }
 
+TEST_F(DeviceTest, givenNoActiveSourceLevelDebuggerWhenGetIsCalledThenNullptrIsReturned) {
+    EXPECT_EQ(nullptr, device->getSourceLevelDebugger());
+}
+
 } // namespace ult
 } // namespace L0