Create separate command stream receiver for every device.

MichalMrozek · Compute-Runtime-Automation · commit 8e33ec04c5ce · 2018-09-12T09:32:41.000+02:00
Change-Id: I8073380941e2a3bfe57610e6e437bdc177dcc2d5
diff --git a/runtime/command_stream/command_stream_receiver.cpp b/runtime/command_stream/command_stream_receiver.cpp
@@ -360,9 +360,6 @@ void CommandStreamReceiver::setExperimentalCmdBuffer(std::unique_ptr<Experimenta
 }
 
 bool CommandStreamReceiver::initializeTagAllocation() {
-    if (tagAllocation) {
-        return true;
-    }
     auto tagAllocation = memoryManager->allocateGraphicsMemory(sizeof(uint32_t));
     if (!tagAllocation) {
         return false;
diff --git a/runtime/device/device.cpp b/runtime/device/device.cpp
@@ -103,8 +103,8 @@ Device::~Device() {
         performanceCounters->shutdown();
     }
 
-    if (executionEnvironment->commandStreamReceiver) {
-        executionEnvironment->commandStreamReceiver->flushBatchedSubmissions();
+    if (commandStreamReceiver) {
+        commandStreamReceiver->flushBatchedSubmissions();
     }
 
     if (deviceInfo.sourceLevelDebuggerActive && executionEnvironment->sourceLevelDebugger) {
@@ -126,15 +126,15 @@ Device::~Device() {
 bool Device::createDeviceImpl(const HardwareInfo *pHwInfo, Device &outDevice) {
     auto executionEnvironment = outDevice.executionEnvironment;
     executionEnvironment->initGmm(pHwInfo);
-    if (!executionEnvironment->initializeCommandStreamReceiver(pHwInfo)) {
+    if (!executionEnvironment->initializeCommandStreamReceiver(pHwInfo, outDevice.getDeviceIndex())) {
         return false;
     }
-    executionEnvironment->initializeMemoryManager(outDevice.getEnabled64kbPages(), outDevice.getHardwareCapabilities().localMemorySupported);
+    executionEnvironment->initializeMemoryManager(outDevice.getEnabled64kbPages(), outDevice.getHardwareCapabilities().localMemorySupported, outDevice.getDeviceIndex());
 
     outDevice.osContext = new OsContext(executionEnvironment->osInterface.get());
     executionEnvironment->memoryManager->registerOsContext(outDevice.osContext);
 
-    outDevice.commandStreamReceiver = executionEnvironment->commandStreamReceiver.get();
+    outDevice.commandStreamReceiver = executionEnvironment->commandStreamReceivers[outDevice.getDeviceIndex()].get();
     if (!outDevice.commandStreamReceiver->initializeTagAllocation()) {
         return false;
     }
@@ -246,7 +246,7 @@ unique_ptr_if_unused<Device> Device::release() {
 
 bool Device::isSimulation() const {
     bool simulation = hwInfo.capabilityTable.isSimulation(hwInfo.pPlatform->usDeviceID);
-    if (executionEnvironment->commandStreamReceiver->getType() != CommandStreamReceiverType::CSR_HW) {
+    if (commandStreamReceiver->getType() != CommandStreamReceiverType::CSR_HW) {
         simulation = true;
     }
     if (hwInfo.pSkuTable->ftrSimulationMode) {
diff --git a/runtime/execution_environment/execution_environment.cpp b/runtime/execution_environment/execution_environment.cpp
@@ -41,29 +41,32 @@ void ExecutionEnvironment::initGmm(const HardwareInfo *hwInfo) {
         gmmHelper.reset(new GmmHelper(hwInfo));
     }
 }
-bool ExecutionEnvironment::initializeCommandStreamReceiver(const HardwareInfo *pHwInfo) {
-    if (this->commandStreamReceiver) {
+bool ExecutionEnvironment::initializeCommandStreamReceiver(const HardwareInfo *pHwInfo, uint32_t deviceIndex) {
+    if (deviceIndex + 1 > commandStreamReceivers.size()) {
+        commandStreamReceivers.resize(deviceIndex + 1);
+    }
+
+    if (this->commandStreamReceivers[deviceIndex]) {
         return true;
     }
-    CommandStreamReceiver *commandStreamReceiver = createCommandStream(pHwInfo, *this);
+    std::unique_ptr<CommandStreamReceiver> commandStreamReceiver(createCommandStream(pHwInfo, *this));
     if (!commandStreamReceiver) {
         return false;
     }
     if (pHwInfo->capabilityTable.ftrRenderCompressedBuffers || pHwInfo->capabilityTable.ftrRenderCompressedImages) {
         commandStreamReceiver->createPageTableManager();
     }
-    this->commandStreamReceiver.reset(commandStreamReceiver);
+    this->commandStreamReceivers[deviceIndex] = std::move(commandStreamReceiver);
     return true;
 }
-void ExecutionEnvironment::initializeMemoryManager(bool enable64KBpages, bool enableLocalMemory) {
+void ExecutionEnvironment::initializeMemoryManager(bool enable64KBpages, bool enableLocalMemory, uint32_t deviceIndex) {
     if (this->memoryManager) {
-        commandStreamReceiver->setMemoryManager(this->memoryManager.get());
+        commandStreamReceivers[deviceIndex]->setMemoryManager(this->memoryManager.get());
         return;
     }
 
-    memoryManager.reset(commandStreamReceiver->createMemoryManager(enable64KBpages, enableLocalMemory));
-    commandStreamReceiver->setMemoryManager(memoryManager.get());
-
+    memoryManager.reset(commandStreamReceivers[deviceIndex]->createMemoryManager(enable64KBpages, enableLocalMemory));
+    commandStreamReceivers[deviceIndex]->setMemoryManager(memoryManager.get());
     DEBUG_BREAK_IF(!this->memoryManager);
 }
 void ExecutionEnvironment::initSourceLevelDebugger(const HardwareInfo &hwInfo) {
diff --git a/runtime/execution_environment/execution_environment.h b/runtime/execution_environment/execution_environment.h
@@ -24,6 +24,7 @@
 #include "runtime/utilities/reference_tracked_object.h"
 
 #include <mutex>
+#include <vector>
 
 namespace OCLRT {
 class GmmHelper;
@@ -48,8 +49,8 @@ class ExecutionEnvironment : public ReferenceTrackedObject<ExecutionEnvironment>
     ~ExecutionEnvironment() override;
 
     void initGmm(const HardwareInfo *hwInfo);
-    bool initializeCommandStreamReceiver(const HardwareInfo *pHwInfo);
-    void initializeMemoryManager(bool enable64KBpages, bool enableLocalMemory);
+    bool initializeCommandStreamReceiver(const HardwareInfo *pHwInfo, uint32_t deviceIndex);
+    void initializeMemoryManager(bool enable64KBpages, bool enableLocalMemory, uint32_t deviceIndex);
     void initSourceLevelDebugger(const HardwareInfo &hwInfo);
 
     GmmHelper *getGmmHelper() const;
@@ -58,7 +59,7 @@ class ExecutionEnvironment : public ReferenceTrackedObject<ExecutionEnvironment>
 
     std::unique_ptr<OSInterface> osInterface;
     std::unique_ptr<MemoryManager> memoryManager;
-    std::unique_ptr<CommandStreamReceiver> commandStreamReceiver;
+    std::vector<std::unique_ptr<CommandStreamReceiver>> commandStreamReceivers;
     std::unique_ptr<BuiltIns> builtins;
     std::unique_ptr<CompilerInterface> compilerInterface;
     std::unique_ptr<SourceLevelDebugger> sourceLevelDebugger;
diff --git a/unit_tests/command_stream/aub_command_stream_receiver_tests.cpp b/unit_tests/command_stream/aub_command_stream_receiver_tests.cpp
@@ -124,7 +124,7 @@ struct AubExecutionEnvironment {
     GraphicsAllocation *commandBuffer = nullptr;
     template <typename CsrType>
     CsrType *getCsr() {
-        return static_cast<CsrType *>(executionEnvironment->commandStreamReceiver.get());
+        return static_cast<CsrType *>(executionEnvironment->commandStreamReceivers[0u].get());
     }
     ~AubExecutionEnvironment() {
         if (commandBuffer) {
@@ -136,11 +136,11 @@ struct AubExecutionEnvironment {
 template <typename CsrType>
 std::unique_ptr<AubExecutionEnvironment> getEnvironment(bool createTagAllocation, bool allocateCommandBuffer, bool standalone) {
     std::unique_ptr<ExecutionEnvironment> executionEnvironment(new ExecutionEnvironment);
-    executionEnvironment->commandStreamReceiver.reset(new CsrType(*platformDevices[0], "", standalone, *executionEnvironment));
-    executionEnvironment->memoryManager.reset(executionEnvironment->commandStreamReceiver->createMemoryManager(false, false));
-    executionEnvironment->commandStreamReceiver->setMemoryManager(executionEnvironment->memoryManager.get());
+    executionEnvironment->commandStreamReceivers.push_back(std::make_unique<CsrType>(*platformDevices[0], "", standalone, *executionEnvironment));
+    executionEnvironment->memoryManager.reset(executionEnvironment->commandStreamReceivers[0u]->createMemoryManager(false, false));
+    executionEnvironment->commandStreamReceivers[0u]->setMemoryManager(executionEnvironment->memoryManager.get());
     if (createTagAllocation) {
-        executionEnvironment->commandStreamReceiver->initializeTagAllocation();
+        executionEnvironment->commandStreamReceivers[0u]->initializeTagAllocation();
     }
 
     std::unique_ptr<AubExecutionEnvironment> aubExecutionEnvironment(new AubExecutionEnvironment);
diff --git a/unit_tests/command_stream/create_command_stream_receiver_tests.cpp b/unit_tests/command_stream/create_command_stream_receiver_tests.cpp
@@ -56,13 +56,13 @@ HWTEST_P(CreateCommandStreamReceiverTest, givenCreateCommandStreamWhenCsrIsSetTo
     overrideCommandStreamReceiverCreation = true;
     DebugManager.flags.SetCommandStreamReceiver.set(csrType);
     ExecutionEnvironment executionEnvironment;
-    executionEnvironment.commandStreamReceiver.reset(createCommandStream(&hwInfo, executionEnvironment));
+    executionEnvironment.commandStreamReceivers.push_back(std::unique_ptr<CommandStreamReceiver>(createCommandStream(&hwInfo, executionEnvironment)));
     if (csrType < CommandStreamReceiverType::CSR_TYPES_NUM) {
-        EXPECT_NE(nullptr, executionEnvironment.commandStreamReceiver.get());
-        executionEnvironment.memoryManager.reset(executionEnvironment.commandStreamReceiver->createMemoryManager(false, false));
+        EXPECT_NE(nullptr, executionEnvironment.commandStreamReceivers[0u].get());
+        executionEnvironment.memoryManager.reset(executionEnvironment.commandStreamReceivers[0u]->createMemoryManager(false, false));
         EXPECT_NE(nullptr, executionEnvironment.memoryManager.get());
     } else {
-        EXPECT_EQ(nullptr, executionEnvironment.commandStreamReceiver.get());
+        EXPECT_EQ(nullptr, executionEnvironment.commandStreamReceivers[0u]);
         EXPECT_EQ(nullptr, executionEnvironment.memoryManager.get());
     }
 }
diff --git a/unit_tests/device/device_tests.cpp b/unit_tests/device/device_tests.cpp
@@ -199,6 +199,19 @@ TEST(DeviceCreation, givenMultiDeviceWhenTheyAreCreatedThenEachDeviceHasSeperate
     EXPECT_EQ(1u, device2->getDeviceIndex());
 }
 
+TEST(DeviceCreation, givenMultiDeviceWhenTheyAreCreatedThenEachDeviceHasSeperateCommandStreamReceiver) {
+    ExecutionEnvironment executionEnvironment;
+    executionEnvironment.incRefInternal();
+    auto device = std::unique_ptr<Device>(Device::create<Device>(nullptr, &executionEnvironment, 0u));
+    auto device2 = std::unique_ptr<Device>(Device::create<Device>(nullptr, &executionEnvironment, 1u));
+
+    EXPECT_EQ(2u, executionEnvironment.commandStreamReceivers.size());
+    EXPECT_NE(nullptr, executionEnvironment.commandStreamReceivers[0]);
+    EXPECT_NE(nullptr, executionEnvironment.commandStreamReceivers[1]);
+    EXPECT_EQ(&device->getCommandStreamReceiver(), executionEnvironment.commandStreamReceivers[0].get());
+    EXPECT_EQ(&device2->getCommandStreamReceiver(), executionEnvironment.commandStreamReceivers[1].get());
+}
+
 TEST(DeviceCreation, givenFtrSimulationModeFlagTrueWhenNoOtherSimulationFlagsArePresentThenIsSimulationReturnsTrue) {
     FeatureTable skuTable = *platformDevices[0]->pSkuTable;
     skuTable.ftrSimulationMode = true;
diff --git a/unit_tests/execution_environment/execution_environment_tests.cpp b/unit_tests/execution_environment/execution_environment_tests.cpp
@@ -85,7 +85,7 @@ TEST(ExecutionEnvironment, givenPlatformWhenItIsCreatedThenItCreatesCommandStrea
     Platform platform;
     auto executionEnvironment = platform.peekExecutionEnvironment();
     platform.initialize();
-    EXPECT_NE(nullptr, executionEnvironment->commandStreamReceiver);
+    EXPECT_NE(nullptr, executionEnvironment->commandStreamReceivers[0u].get());
 }
 
 TEST(ExecutionEnvironment, givenPlatformWhenItIsCreatedThenItCreatesMemoryManagerInExecutionEnvironment) {
@@ -105,18 +105,42 @@ TEST(ExecutionEnvironment, givenDeviceWhenItIsDestroyedThenMemoryManagerIsStillA
 
 TEST(ExecutionEnvironment, givenExecutionEnvironmentWhenInitializeCommandStreamReceiverIsCalledThenItIsInitalized) {
     std::unique_ptr<ExecutionEnvironment> executionEnvironment(new ExecutionEnvironment);
-    executionEnvironment->initializeCommandStreamReceiver(platformDevices[0]);
-    EXPECT_NE(nullptr, executionEnvironment->commandStreamReceiver);
+    executionEnvironment->initializeCommandStreamReceiver(platformDevices[0], 0u);
+    EXPECT_NE(nullptr, executionEnvironment->commandStreamReceivers[0u]);
 }
 
-TEST(ExecutionEnvironment, givenExecutionEnvironmentWhenInitializeMemoryManagerIsCalledThenItIsInitalized) {
+TEST(ExecutionEnvironment, givenExecutionEnvironmentWhenInitializeIsCalledWithDifferentDeviceIndexesThenInternalStorageIsResized) {
     std::unique_ptr<ExecutionEnvironment> executionEnvironment(new ExecutionEnvironment);
-    executionEnvironment->initializeCommandStreamReceiver(platformDevices[0]);
-    executionEnvironment->initializeMemoryManager(false, false);
-    EXPECT_NE(nullptr, executionEnvironment->memoryManager);
+    EXPECT_EQ(0u, executionEnvironment->commandStreamReceivers.size());
+    executionEnvironment->initializeCommandStreamReceiver(platformDevices[0], 0u);
+    EXPECT_EQ(1u, executionEnvironment->commandStreamReceivers.size());
+    EXPECT_NE(nullptr, executionEnvironment->commandStreamReceivers[0u]);
+    executionEnvironment->initializeCommandStreamReceiver(platformDevices[0], 1u);
+    EXPECT_EQ(2u, executionEnvironment->commandStreamReceivers.size());
+    EXPECT_NE(nullptr, executionEnvironment->commandStreamReceivers[1u]);
+}
+
+TEST(ExecutionEnvironment, givenExecutionEnvironmentWhenInitializeIsCalledMultipleTimesForTheSameIndexThenCommandStreamReceiverIsReused) {
+    auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
+    EXPECT_EQ(0u, executionEnvironment->commandStreamReceivers.size());
+    executionEnvironment->initializeCommandStreamReceiver(platformDevices[0], 1u);
+
+    auto currentCommandStreamReceiver = executionEnvironment->commandStreamReceivers[1u].get();
+
+    executionEnvironment->initializeCommandStreamReceiver(platformDevices[0], 1u);
+
+    EXPECT_EQ(currentCommandStreamReceiver, executionEnvironment->commandStreamReceivers[1u].get());
+    EXPECT_EQ(2u, executionEnvironment->commandStreamReceivers.size());
+    EXPECT_EQ(nullptr, executionEnvironment->commandStreamReceivers[0u].get());
 }
 
-static_assert(sizeof(ExecutionEnvironment) == sizeof(std::mutex) + (is64bit ? 80 : 44), "New members detected in ExecutionEnvironment, please ensure that destruction sequence of objects is correct");
+TEST(ExecutionEnvironment, givenExecutionEnvironmentWhenInitializeMemoryManagerIsCalledThenItIsInitalized) {
+    auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
+    executionEnvironment->initializeCommandStreamReceiver(platformDevices[0], 0u);
+    executionEnvironment->initializeMemoryManager(false, false, 0u);
+    EXPECT_NE(nullptr, executionEnvironment->memoryManager);
+}
+static_assert(sizeof(ExecutionEnvironment) == sizeof(std::vector<std::unique_ptr<CommandStreamReceiver>>) + sizeof(std::mutex) + (is64bit ? 72 : 40), "New members detected in ExecutionEnvironment, please ensure that destruction sequence of objects is correct");
 
 TEST(ExecutionEnvironment, givenExecutionEnvironmentWithVariousMembersWhenItIsDestroyedThenDeleteSequenceIsSpecified) {
     uint32_t destructorId = 0u;
@@ -150,7 +174,7 @@ TEST(ExecutionEnvironment, givenExecutionEnvironmentWithVariousMembersWhenItIsDe
     executionEnvironment->gmmHelper = std::make_unique<GmmHelperMock>(destructorId, platformDevices[0]);
     executionEnvironment->osInterface = std::make_unique<OsInterfaceMock>(destructorId);
     executionEnvironment->memoryManager = std::make_unique<MemoryMangerMock>(destructorId);
-    executionEnvironment->commandStreamReceiver = std::make_unique<CommandStreamReceiverMock>(destructorId);
+    executionEnvironment->commandStreamReceivers.push_back(std::make_unique<CommandStreamReceiverMock>(destructorId));
     executionEnvironment->builtins = std::make_unique<BuiltinsMock>(destructorId);
     executionEnvironment->compilerInterface = std::make_unique<CompilerInterfaceMock>(destructorId);
     executionEnvironment->sourceLevelDebugger = std::make_unique<SourceLevelDebuggerMock>(destructorId);
@@ -166,7 +190,7 @@ TEST(ExecutionEnvironment, givenMultipleDevicesWhenTheyAreCreatedTheyAllReuseThe
     auto memoryManager = device->getMemoryManager();
 
     std::unique_ptr<Device> device2(Device::create<OCLRT::Device>(nullptr, executionEnvironment, 1u));
-    EXPECT_EQ(&commandStreamReceiver, &device->getCommandStreamReceiver());
+    EXPECT_NE(&commandStreamReceiver, &device2->getCommandStreamReceiver());
     EXPECT_EQ(memoryManager, device2->getMemoryManager());
 }
 
@@ -176,8 +200,8 @@ HWTEST_F(ExecutionEnvironmentHw, givenExecutionEnvironmentWhenCommandStreamRecei
     ExecutionEnvironment executionEnvironment;
     HardwareInfo localHwInfo = *platformDevices[0];
     localHwInfo.capabilityTable.ftrRenderCompressedBuffers = true;
-    executionEnvironment.initializeCommandStreamReceiver(&localHwInfo);
-    auto csr = static_cast<UltCommandStreamReceiver<FamilyType> *>(executionEnvironment.commandStreamReceiver.get());
+    executionEnvironment.initializeCommandStreamReceiver(&localHwInfo, 0u);
+    auto csr = static_cast<UltCommandStreamReceiver<FamilyType> *>(executionEnvironment.commandStreamReceivers[0u].get());
     ASSERT_NE(nullptr, csr);
     EXPECT_TRUE(csr->createPageTableManagerCalled);
 }
@@ -186,9 +210,9 @@ HWTEST_F(ExecutionEnvironmentHw, givenExecutionEnvironmentWhenCommandStreamRecei
     ExecutionEnvironment executionEnvironment;
     HardwareInfo localHwInfo = *platformDevices[0];
     localHwInfo.capabilityTable.ftrRenderCompressedImages = true;
-    executionEnvironment.initializeCommandStreamReceiver(&localHwInfo);
-    EXPECT_NE(nullptr, executionEnvironment.commandStreamReceiver);
-    auto csr = static_cast<UltCommandStreamReceiver<FamilyType> *>(executionEnvironment.commandStreamReceiver.get());
+    executionEnvironment.initializeCommandStreamReceiver(&localHwInfo, 0u);
+    EXPECT_NE(nullptr, executionEnvironment.commandStreamReceivers[0]);
+    auto csr = static_cast<UltCommandStreamReceiver<FamilyType> *>(executionEnvironment.commandStreamReceivers[0u].get());
     ASSERT_NE(nullptr, csr);
     EXPECT_TRUE(csr->createPageTableManagerCalled);
 }
diff --git a/unit_tests/mocks/mock_device.cpp b/unit_tests/mocks/mock_device.cpp
diff --git a/unit_tests/mocks/mock_device.h b/unit_tests/mocks/mock_device.h
diff --git a/unit_tests/os_interface/windows/device_command_stream_tests.cpp b/unit_tests/os_interface/windows/device_command_stream_tests.cpp

Original file line number	Diff line number	Diff line change
`@@ -360,9 +360,6 @@ void CommandStreamReceiver::setExperimentalCmdBuffer(std::unique_ptr<Experimenta`
`360`	`360`	`}`
`361`	`361`
`362`	`362`	`bool CommandStreamReceiver::initializeTagAllocation() {`
`363`		`- if (tagAllocation) {`
`364`		`- return true;`
`365`		`- }`
`366`	`363`	`auto tagAllocation = memoryManager->allocateGraphicsMemory(sizeof(uint32_t));`
`367`	`364`	`if (!tagAllocation) {`
`368`	`365`	`return false;`
Original file line number	Diff line number	Diff line change
`@@ -41,29 +41,32 @@ void ExecutionEnvironment::initGmm(const HardwareInfo *hwInfo) {`
`41`	`41`	`gmmHelper.reset(new GmmHelper(hwInfo));`
`42`	`42`	`}`
`43`	`43`	`}`
`44`		`-bool ExecutionEnvironment::initializeCommandStreamReceiver(const HardwareInfo *pHwInfo) {`
`45`		`- if (this->commandStreamReceiver) {`
	`44`	`+bool ExecutionEnvironment::initializeCommandStreamReceiver(const HardwareInfo *pHwInfo, uint32_t deviceIndex) {`
	`45`	`+ if (deviceIndex + 1 > commandStreamReceivers.size()) {`
	`46`	`+ commandStreamReceivers.resize(deviceIndex + 1);`
	`47`	`+ }`
	`48`	`+`
	`49`	`+ if (this->commandStreamReceivers[deviceIndex]) {`
`46`	`50`	`return true;`
`47`	`51`	`}`
`48`		`- CommandStreamReceiver commandStreamReceiver = createCommandStream(pHwInfo, this);`
	`52`	`+ std::unique_ptr<CommandStreamReceiver> commandStreamReceiver(createCommandStream(pHwInfo, *this));`
`49`	`53`	`if (!commandStreamReceiver) {`
`50`	`54`	`return false;`
`51`	`55`	`}`
`52`	`56`	`if (pHwInfo->capabilityTable.ftrRenderCompressedBuffers \|\| pHwInfo->capabilityTable.ftrRenderCompressedImages) {`
`53`	`57`	`commandStreamReceiver->createPageTableManager();`
`54`	`58`	`}`
`55`		`- this->commandStreamReceiver.reset(commandStreamReceiver);`
	`59`	`+ this->commandStreamReceivers[deviceIndex] = std::move(commandStreamReceiver);`
`56`	`60`	`return true;`
`57`	`61`	`}`
`58`		`-void ExecutionEnvironment::initializeMemoryManager(bool enable64KBpages, bool enableLocalMemory) {`
	`62`	`+void ExecutionEnvironment::initializeMemoryManager(bool enable64KBpages, bool enableLocalMemory, uint32_t deviceIndex) {`
`59`	`63`	`if (this->memoryManager) {`
`60`		`- commandStreamReceiver->setMemoryManager(this->memoryManager.get());`
	`64`	`+ commandStreamReceivers[deviceIndex]->setMemoryManager(this->memoryManager.get());`
`61`	`65`	`return;`
`62`	`66`	`}`
`63`	`67`
`64`		`- memoryManager.reset(commandStreamReceiver->createMemoryManager(enable64KBpages, enableLocalMemory));`
`65`		`- commandStreamReceiver->setMemoryManager(memoryManager.get());`
`66`		`-`
	`68`	`+ memoryManager.reset(commandStreamReceivers[deviceIndex]->createMemoryManager(enable64KBpages, enableLocalMemory));`
	`69`	`+ commandStreamReceivers[deviceIndex]->setMemoryManager(memoryManager.get());`
`67`	`70`	`DEBUG_BREAK_IF(!this->memoryManager);`
`68`	`71`	`}`
`69`	`72`	`void ExecutionEnvironment::initSourceLevelDebugger(const HardwareInfo &hwInfo) {`