Simplify RootDevice class

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

Author: BartoszDunajski

level_zero/core/test/unit_tests/sources/memory/test_memory.cpp

@@ -1982,8 +1982,7 @@ struct MemoryBitfieldTest : testing::Test {
         executionEnvironment->rootDeviceEnvironments[0]->setHwInfo(defaultHwInfo.get());
         memoryManager = new NEO::MockMemoryManager(*executionEnvironment);
         executionEnvironment->memoryManager.reset(memoryManager);
-        neoDevice = new NEO::RootDevice(executionEnvironment, 0);
-        static_cast<RootDevice *>(neoDevice)->createDeviceImpl();
+        neoDevice = NEO::Device::create<RootDevice>(executionEnvironment, 0u);
         NEO::DeviceVector devices;
         devices.push_back(std::unique_ptr<NEO::Device>(neoDevice));
         driverHandle = std::make_unique<Mock<L0::DriverHandleImp>>();
@@ -2041,11 +2040,10 @@ TEST(MemoryBitfieldTests, givenDeviceWithValidBitfieldWhenAllocatingSharedMemory
     }
     auto memoryManager = new NEO::MockMemoryManager(*executionEnvironment);
     executionEnvironment->memoryManager.reset(memoryManager);
-    NEO::Device *neoDevice0 = new NEO::RootDevice(executionEnvironment, 0);
-    static_cast<NEO::RootDevice *>(neoDevice0)->createDeviceImpl();
+    NEO::Device *neoDevice0 = NEO::Device::create<RootDevice>(executionEnvironment, 0u);
     DebugManager.flags.CreateMultipleSubDevices.set(4);
-    NEO::Device *neoDevice1 = new NEO::RootDevice(executionEnvironment, 1);
-    static_cast<NEO::RootDevice *>(neoDevice1)->createDeviceImpl();
+    NEO::Device *neoDevice1 = NEO::Device::create<RootDevice>(executionEnvironment, 1u);
+
     NEO::DeviceVector devices;
     devices.push_back(std::unique_ptr<NEO::Device>(neoDevice0));
     devices.push_back(std::unique_ptr<NEO::Device>(neoDevice1));

opencl/test/unit_test/device/device_caps_tests.cpp

@@ -545,9 +545,15 @@ TEST_F(DeviceGetCapsTest, givenEnableSharingFormatQuerySetTrueAndEnabledMultiple
     DebugManagerStateRestore dbgRestorer;
     DebugManager.flags.EnableFormatQuery.set(true);
     DebugManager.flags.CreateMultipleSubDevices.set(2);
-    auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get()));
-    const auto &caps = device->getDeviceInfo();
-    EXPECT_THAT(caps.deviceExtensions, ::testing::HasSubstr(std::string("cl_intel_sharing_format_query ")));
+
+    auto rootDevice = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get()));
+    EXPECT_THAT(rootDevice->getDeviceInfo().deviceExtensions, ::testing::Not(::testing::HasSubstr(std::string("cl_intel_sharing_format_query "))));
+
+    auto subDevice0 = rootDevice->getDeviceById(0);
+    EXPECT_THAT(subDevice0->getDeviceInfo().deviceExtensions, ::testing::HasSubstr(std::string("cl_intel_sharing_format_query ")));
+
+    auto subDevice1 = rootDevice->getDeviceById(1);
+    EXPECT_THAT(subDevice1->getDeviceInfo().deviceExtensions, ::testing::HasSubstr(std::string("cl_intel_sharing_format_query ")));
 }
 
 TEST_F(DeviceGetCapsTest, givenOpenCLVersion20WhenCapsAreCreatedThenDeviceDoesntReportClKhrSubgroupsExtension) {

shared/source/device/device.cpp

@@ -57,7 +57,46 @@ Device::~Device() {
     executionEnvironment->decRefInternal();
 }
 
+SubDevice *Device::createSubDevice(uint32_t subDeviceIndex) {
+    return Device::create<SubDevice>(executionEnvironment, subDeviceIndex, *getRootDevice());
+}
+
+bool Device::createSubDevices() {
+    if (!subDevicesAllowed()) {
+        return true;
+    }
+
+    auto deviceMask = executionEnvironment->rootDeviceEnvironments[getRootDeviceIndex()]->deviceAffinityMask;
+    uint32_t subDeviceCount = HwHelper::getSubDevicesCount(&getHardwareInfo());
+    deviceBitfield = maxNBitValue(subDeviceCount);
+    deviceBitfield &= deviceMask;
+    numSubDevices = static_cast<uint32_t>(deviceBitfield.count());
+    if (numSubDevices == 1) {
+        numSubDevices = 0;
+    }
+    UNRECOVERABLE_IF(!subdevices.empty());
+    if (numSubDevices) {
+        subdevices.resize(subDeviceCount, nullptr);
+        for (auto i = 0u; i < subDeviceCount; i++) {
+            if (!deviceBitfield.test(i)) {
+                continue;
+            }
+            auto subDevice = createSubDevice(i);
+            if (!subDevice) {
+                return false;
+            }
+            subdevices[i] = subDevice;
+        }
+    }
+
+    return true;
+}
+
 bool Device::createDeviceImpl() {
+    if (!createSubDevices()) {
+        return false;
+    }
+
     auto &hwInfo = getHardwareInfo();
     preemptionMode = PreemptionHelper::getDefaultPreemptionMode(hwInfo);
 
@@ -120,6 +159,8 @@ bool Device::createDeviceImpl() {
         getRootDeviceEnvironment().tagsManager->initialize(*this);
     }
 
+    createBindlessHeapsHelper();
+
     return true;
 }
 

shared/source/device/device.h

@@ -126,12 +126,16 @@ class Device : public ReferenceTrackedObject<Device> {
         return device;
     }
 
-    virtual bool createDeviceImpl();
+    MOCKABLE_VIRTUAL bool createDeviceImpl();
     virtual bool createEngines();
     void addEngineToEngineGroup(EngineControl &engine);
     bool createEngine(uint32_t deviceCsrIndex, EngineTypeUsage engineTypeUsage);
     MOCKABLE_VIRTUAL std::unique_ptr<CommandStreamReceiver> createCommandStreamReceiver() const;
+    MOCKABLE_VIRTUAL SubDevice *createSubDevice(uint32_t subDeviceIndex);
     virtual uint64_t getGlobalMemorySize(uint32_t deviceBitfield) const;
+    virtual void createBindlessHeapsHelper() {}
+    bool createSubDevices();
+    virtual bool subDevicesAllowed() const { return true; };
 
     DeviceInfo deviceInfo = {};
 

shared/source/device/root_device.cpp

@@ -12,7 +12,6 @@
 #include "shared/source/debug_settings/debug_settings_manager.h"
 #include "shared/source/device/sub_device.h"
 #include "shared/source/helpers/api_specific_config.h"
-#include "shared/source/helpers/bindless_heaps_helper.h"
 #include "shared/source/helpers/hw_helper.h"
 #include "shared/source/memory_manager/memory_manager.h"
 #include "shared/source/utilities/software_tags_manager.h"
@@ -38,42 +37,10 @@ Device *RootDevice::getRootDevice() const {
     return const_cast<RootDevice *>(this);
 }
 
-SubDevice *RootDevice::createSubDevice(uint32_t subDeviceIndex) {
-    return Device::create<SubDevice>(executionEnvironment, subDeviceIndex, *this);
-}
-
-bool RootDevice::createDeviceImpl() {
-    auto deviceMask = executionEnvironment->rootDeviceEnvironments[this->rootDeviceIndex]->deviceAffinityMask;
-    uint32_t subDeviceCount = HwHelper::getSubDevicesCount(&getHardwareInfo());
-    deviceBitfield = maxNBitValue(subDeviceCount);
-    deviceBitfield &= deviceMask;
-    numSubDevices = static_cast<uint32_t>(deviceBitfield.count());
-    if (numSubDevices == 1) {
-        numSubDevices = 0;
-    }
-    UNRECOVERABLE_IF(!subdevices.empty());
-    if (numSubDevices) {
-        subdevices.resize(subDeviceCount, nullptr);
-        for (auto i = 0u; i < subDeviceCount; i++) {
-            if (!deviceBitfield.test(i)) {
-                continue;
-            }
-            auto subDevice = createSubDevice(i);
-            if (!subDevice) {
-                return false;
-            }
-            subdevices[i] = subDevice;
-        }
-    }
-    auto status = Device::createDeviceImpl();
-    if (!status) {
-        return status;
-    }
+void RootDevice::createBindlessHeapsHelper() {
     if (ApiSpecificConfig::getBindlessConfiguration()) {
         this->executionEnvironment->rootDeviceEnvironments[getRootDeviceIndex()]->createBindlessHeapsHelper(getMemoryManager(), getNumAvailableDevices() > 1, rootDeviceIndex);
     }
-
-    return true;
 }
 
 bool RootDevice::createEngines() {

shared/source/device/root_device.h

@@ -16,17 +16,16 @@ class RootDevice : public Device {
   public:
     RootDevice(ExecutionEnvironment *executionEnvironment, uint32_t rootDeviceIndex);
     ~RootDevice() override;
-    bool createDeviceImpl() override;
 
     uint32_t getRootDeviceIndex() const override;
     Device *getRootDevice() const override;
     bool isSubDevice() const override { return false; }
 
   protected:
     bool createEngines() override;
+    void createBindlessHeapsHelper() override;
 
     void initializeRootCommandStreamReceiver();
-    MOCKABLE_VIRTUAL SubDevice *createSubDevice(uint32_t subDeviceIndex);
 
     const uint32_t rootDeviceIndex;
 };

shared/source/device/sub_device.cpp

@@ -11,8 +11,9 @@
 
 namespace NEO {
 
-SubDevice::SubDevice(ExecutionEnvironment *executionEnvironment, uint32_t subDeviceIndex, RootDevice &rootDevice)
-    : Device(executionEnvironment), subDeviceIndex(subDeviceIndex), rootDevice(rootDevice) {
+SubDevice::SubDevice(ExecutionEnvironment *executionEnvironment, uint32_t subDeviceIndex, Device &rootDevice)
+    : Device(executionEnvironment), subDeviceIndex(subDeviceIndex), rootDevice(static_cast<RootDevice &>(rootDevice)) {
+    UNRECOVERABLE_IF(rootDevice.isSubDevice());
     deviceBitfield = 0;
     deviceBitfield.set(subDeviceIndex);
 }

shared/source/device/sub_device.h

@@ -12,7 +12,7 @@ namespace NEO {
 class RootDevice;
 class SubDevice : public Device {
   public:
-    SubDevice(ExecutionEnvironment *executionEnvironment, uint32_t subDeviceIndex, RootDevice &rootDevice);
+    SubDevice(ExecutionEnvironment *executionEnvironment, uint32_t subDeviceIndex, Device &rootDevice);
     void incRefInternal() override;
     unique_ptr_if_unused<Device> decRefInternal() override;
 
@@ -25,6 +25,7 @@ class SubDevice : public Device {
 
   protected:
     uint64_t getGlobalMemorySize(uint32_t deviceBitfield) const override;
+    bool subDevicesAllowed() const override { return false; };
     const uint32_t subDeviceIndex;
     RootDevice &rootDevice;
 };