Pass aubfile name to TbxCommandStreamReceiver::create and CSRWithAubDump

HoppeMateusz · Compute-Runtime-Automation · commit 4d9acf335260 · 2019-02-07T15:05:54.000+01:00
Change-Id: Ib10c017ce4ed2a572815053dae3f517e0dfd9eb3
diff --git a/runtime/command_stream/command_stream_receiver_with_aub_dump.h b/runtime/command_stream/command_stream_receiver_with_aub_dump.h
@@ -17,7 +17,7 @@ class CommandStreamReceiverWithAUBDump : public BaseCSR {
 
   public:
     using BaseCSR::createMemoryManager;
-    CommandStreamReceiverWithAUBDump(const HardwareInfo &hwInfoIn, ExecutionEnvironment &executionEnvironment);
+    CommandStreamReceiverWithAUBDump(const HardwareInfo &hwInfoIn, const std::string &baseName, ExecutionEnvironment &executionEnvironment);
     ~CommandStreamReceiverWithAUBDump() override;
 
     CommandStreamReceiverWithAUBDump(const CommandStreamReceiverWithAUBDump &) = delete;
diff --git a/runtime/command_stream/command_stream_receiver_with_aub_dump.inl b/runtime/command_stream/command_stream_receiver_with_aub_dump.inl
@@ -5,6 +5,7 @@
  *
  */
 
+#include "runtime/aub/aub_center.h"
 #include "runtime/command_stream/command_stream_receiver_with_aub_dump.h"
 #include "runtime/command_stream/aub_command_stream_receiver.h"
 
@@ -13,14 +14,20 @@ namespace OCLRT {
 extern CommandStreamReceiverCreateFunc commandStreamReceiverFactory[2 * IGFX_MAX_CORE];
 
 template <typename BaseCSR>
-CommandStreamReceiverWithAUBDump<BaseCSR>::CommandStreamReceiverWithAUBDump(const HardwareInfo &hwInfoIn, ExecutionEnvironment &executionEnvironment)
+CommandStreamReceiverWithAUBDump<BaseCSR>::CommandStreamReceiverWithAUBDump(const HardwareInfo &hwInfoIn, const std::string &baseName, ExecutionEnvironment &executionEnvironment)
     : BaseCSR(hwInfoIn, executionEnvironment) {
-    aubCSR = AUBCommandStreamReceiver::create(hwInfoIn, "aubfile", false, executionEnvironment);
+    bool createAubCsr = !executionEnvironment.aubCenter || executionEnvironment.aubCenter->getAubManager() == nullptr;
+
+    if (createAubCsr) {
+        aubCSR = AUBCommandStreamReceiver::create(hwInfoIn, baseName, false, executionEnvironment);
+    }
 }
 
 template <typename BaseCSR>
 CommandStreamReceiverWithAUBDump<BaseCSR>::~CommandStreamReceiverWithAUBDump() {
-    delete aubCSR;
+    if (aubCSR) {
+        delete aubCSR;
+    }
 }
 
 template <typename BaseCSR>
diff --git a/runtime/command_stream/create_command_stream_impl.cpp b/runtime/command_stream/create_command_stream_impl.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2018 Intel Corporation
+ * Copyright (C) 2018-2019 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -29,13 +29,13 @@ CommandStreamReceiver *createCommandStreamImpl(const HardwareInfo *pHwInfo, Exec
             commandStreamReceiver = AUBCommandStreamReceiver::create(*pHwInfo, "aubfile", true, executionEnvironment);
             break;
         case CSR_TBX:
-            commandStreamReceiver = TbxCommandStreamReceiver::create(*pHwInfo, false, executionEnvironment);
+            commandStreamReceiver = TbxCommandStreamReceiver::create(*pHwInfo, "", false, executionEnvironment);
             break;
         case CSR_HW_WITH_AUB:
             commandStreamReceiver = funcCreate(*pHwInfo, true, executionEnvironment);
             break;
         case CSR_TBX_WITH_AUB:
-            commandStreamReceiver = TbxCommandStreamReceiver::create(*pHwInfo, true, executionEnvironment);
+            commandStreamReceiver = TbxCommandStreamReceiver::create(*pHwInfo, "aubfile", true, executionEnvironment);
             break;
         default:
             break;
diff --git a/runtime/command_stream/tbx_command_stream_receiver.cpp b/runtime/command_stream/tbx_command_stream_receiver.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2017-2018 Intel Corporation
+ * Copyright (C) 2017-2019 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -14,7 +14,7 @@ namespace OCLRT {
 
 TbxCommandStreamReceiverCreateFunc tbxCommandStreamReceiverFactory[IGFX_MAX_CORE] = {};
 
-CommandStreamReceiver *TbxCommandStreamReceiver::create(const HardwareInfo &hwInfo, bool withAubDump, ExecutionEnvironment &executionEnvironment) {
+CommandStreamReceiver *TbxCommandStreamReceiver::create(const HardwareInfo &hwInfo, const std::string &baseName, bool withAubDump, ExecutionEnvironment &executionEnvironment) {
 
     if (hwInfo.pPlatform->eRenderCoreFamily >= IGFX_MAX_CORE) {
         DEBUG_BREAK_IF(!false);
@@ -23,6 +23,6 @@ CommandStreamReceiver *TbxCommandStreamReceiver::create(const HardwareInfo &hwIn
 
     auto pCreate = tbxCommandStreamReceiverFactory[hwInfo.pPlatform->eRenderCoreFamily];
 
-    return pCreate ? pCreate(hwInfo, withAubDump, executionEnvironment) : nullptr;
+    return pCreate ? pCreate(hwInfo, baseName, withAubDump, executionEnvironment) : nullptr;
 }
 } // namespace OCLRT
diff --git a/runtime/command_stream/tbx_command_stream_receiver.h b/runtime/command_stream/tbx_command_stream_receiver.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2017-2018 Intel Corporation
+ * Copyright (C) 2017-2019 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -45,10 +45,10 @@ class TbxStream : public AubMemDump::AubStream {
 };
 
 struct TbxCommandStreamReceiver {
-    static CommandStreamReceiver *create(const HardwareInfo &hwInfo, bool withAubDump, ExecutionEnvironment &executionEnvironment);
+    static CommandStreamReceiver *create(const HardwareInfo &hwInfo, const std::string &baseName, bool withAubDump, ExecutionEnvironment &executionEnvironment);
 
     using TbxStream = OCLRT::TbxStream;
 };
 
-typedef CommandStreamReceiver *(*TbxCommandStreamReceiverCreateFunc)(const HardwareInfo &hwInfoIn, bool withAubDump, ExecutionEnvironment &executionEnvironment);
+typedef CommandStreamReceiver *(*TbxCommandStreamReceiverCreateFunc)(const HardwareInfo &hwInfoIn, const std::string &baseName, bool withAubDump, ExecutionEnvironment &executionEnvironment);
 } // namespace OCLRT
diff --git a/runtime/command_stream/tbx_command_stream_receiver_hw.h b/runtime/command_stream/tbx_command_stream_receiver_hw.h
@@ -55,7 +55,7 @@ class TbxCommandStreamReceiverHw : public CommandStreamReceiverSimulatedHw<GfxFa
     MOCKABLE_VIRTUAL void submitBatchBuffer(uint64_t batchBufferGpuAddress, const void *batchBuffer, size_t batchBufferSize, uint32_t memoryBank, uint64_t entryBits);
     MOCKABLE_VIRTUAL void pollForCompletion();
 
-    static CommandStreamReceiver *create(const HardwareInfo &hwInfoIn, bool withAubDump, ExecutionEnvironment &executionEnvironment);
+    static CommandStreamReceiver *create(const HardwareInfo &hwInfoIn, const std::string &baseName, bool withAubDump, ExecutionEnvironment &executionEnvironment);
 
     TbxCommandStreamReceiverHw(const HardwareInfo &hwInfoIn, ExecutionEnvironment &executionEnvironment);
     ~TbxCommandStreamReceiverHw() override;
diff --git a/runtime/command_stream/tbx_command_stream_receiver_hw.inl b/runtime/command_stream/tbx_command_stream_receiver_hw.inl
@@ -166,10 +166,14 @@ void TbxCommandStreamReceiverHw<GfxFamily>::initializeEngine() {
 }
 
 template <typename GfxFamily>
-CommandStreamReceiver *TbxCommandStreamReceiverHw<GfxFamily>::create(const HardwareInfo &hwInfoIn, bool withAubDump, ExecutionEnvironment &executionEnvironment) {
+CommandStreamReceiver *TbxCommandStreamReceiverHw<GfxFamily>::create(const HardwareInfo &hwInfoIn, const std::string &baseName, bool withAubDump, ExecutionEnvironment &executionEnvironment) {
     TbxCommandStreamReceiverHw<GfxFamily> *csr;
     if (withAubDump) {
-        csr = new CommandStreamReceiverWithAUBDump<TbxCommandStreamReceiverHw<GfxFamily>>(hwInfoIn, executionEnvironment);
+        auto &hwHelper = HwHelper::get(hwInfoIn.pPlatform->eRenderCoreFamily);
+        auto localMemoryEnabled = hwHelper.isLocalMemoryEnabled(hwInfoIn);
+        executionEnvironment.initAubCenter(&hwInfoIn, localMemoryEnabled, baseName);
+
+        csr = new CommandStreamReceiverWithAUBDump<TbxCommandStreamReceiverHw<GfxFamily>>(hwInfoIn, baseName, executionEnvironment);
     } else {
         csr = new TbxCommandStreamReceiverHw<GfxFamily>(hwInfoIn, executionEnvironment);
     }
diff --git a/runtime/os_interface/linux/device_command_stream.inl b/runtime/os_interface/linux/device_command_stream.inl
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2017-2018 Intel Corporation
+ * Copyright (C) 2017-2019 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -16,7 +16,7 @@ namespace OCLRT {
 template <typename GfxFamily>
 CommandStreamReceiver *DeviceCommandStreamReceiver<GfxFamily>::create(const HardwareInfo &hwInfo, bool withAubDump, ExecutionEnvironment &executionEnvironment) {
     if (withAubDump) {
-        return new CommandStreamReceiverWithAUBDump<DrmCommandStreamReceiver<GfxFamily>>(hwInfo, executionEnvironment);
+        return new CommandStreamReceiverWithAUBDump<DrmCommandStreamReceiver<GfxFamily>>(hwInfo, "aubfile", executionEnvironment);
     } else {
         return new DrmCommandStreamReceiver<GfxFamily>(hwInfo, executionEnvironment);
     }
diff --git a/runtime/os_interface/windows/device_command_stream.inl b/runtime/os_interface/windows/device_command_stream.inl
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2017-2018 Intel Corporation
+ * Copyright (C) 2017-2019 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -20,7 +20,7 @@ namespace OCLRT {
 template <typename GfxFamily>
 CommandStreamReceiver *DeviceCommandStreamReceiver<GfxFamily>::create(const HardwareInfo &hwInfo, bool withAubDump, ExecutionEnvironment &executionEnvironment) {
     if (withAubDump) {
-        return new CommandStreamReceiverWithAUBDump<WddmCommandStreamReceiver<GfxFamily>>(hwInfo, executionEnvironment);
+        return new CommandStreamReceiverWithAUBDump<WddmCommandStreamReceiver<GfxFamily>>(hwInfo, "aubfile", executionEnvironment);
     } else {
         return new WddmCommandStreamReceiver<GfxFamily>(hwInfo, executionEnvironment);
     }
diff --git a/unit_tests/aub_tests/command_queue/enqueue_write_copy_read_buffer_aub_tests.cpp b/unit_tests/aub_tests/command_queue/enqueue_write_copy_read_buffer_aub_tests.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2017-2018 Intel Corporation
+ * Copyright (C) 2017-2019 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -45,11 +45,13 @@ void AubWriteCopyReadBuffer::runTest() {
         retVal));
     ASSERT_NE(nullptr, dstBuffer);
 
-    aubCsr->writeMemory(*srcBuffer->getGraphicsAllocation());
-    aubCsr->writeMemory(*dstBuffer->getGraphicsAllocation());
+    if (aubCsr) {
+        aubCsr->writeMemory(*srcBuffer->getGraphicsAllocation());
+        aubCsr->writeMemory(*dstBuffer->getGraphicsAllocation());
 
-    getAubCsr<FamilyType>()->expectMemoryEqual(AUBFixture::getGpuPointer(srcBuffer->getGraphicsAllocation()), srcMemoryInitial, bufferSize);
-    getAubCsr<FamilyType>()->expectMemoryEqual(AUBFixture::getGpuPointer(dstBuffer->getGraphicsAllocation()), dstMemoryInitial, bufferSize);
+        aubCsr->expectMemoryEqual(AUBFixture::getGpuPointer(srcBuffer->getGraphicsAllocation()), srcMemoryInitial, bufferSize);
+        aubCsr->expectMemoryEqual(AUBFixture::getGpuPointer(dstBuffer->getGraphicsAllocation()), dstMemoryInitial, bufferSize);
+    }
 
     cl_uint numEventsInWaitList = 0;
     cl_event *eventWaitList = nullptr;
@@ -79,8 +81,10 @@ void AubWriteCopyReadBuffer::runTest() {
 
     EXPECT_EQ(CL_SUCCESS, retVal);
 
-    getAubCsr<FamilyType>()->expectMemoryEqual(AUBFixture::getGpuPointer(srcBuffer->getGraphicsAllocation()), srcMemoryToWrite, bufferSize);
-    getAubCsr<FamilyType>()->expectMemoryEqual(AUBFixture::getGpuPointer(dstBuffer->getGraphicsAllocation()), dstMemoryToWrite, bufferSize);
+    if (aubCsr) {
+        aubCsr->expectMemoryEqual(AUBFixture::getGpuPointer(srcBuffer->getGraphicsAllocation()), srcMemoryToWrite, bufferSize);
+        aubCsr->expectMemoryEqual(AUBFixture::getGpuPointer(dstBuffer->getGraphicsAllocation()), dstMemoryToWrite, bufferSize);
+    }
 
     retVal = pCmdQ->enqueueCopyBuffer(
         srcBuffer.get(),
@@ -96,8 +100,10 @@ void AubWriteCopyReadBuffer::runTest() {
 
     pCmdQ->flush();
 
-    // Destination buffer should have src buffer content
-    getAubCsr<FamilyType>()->expectMemoryEqual(AUBFixture::getGpuPointer(dstBuffer->getGraphicsAllocation()), srcMemoryToWrite, bufferSize);
+    if (aubCsr) {
+        // Destination buffer should have src buffer content
+        aubCsr->expectMemoryEqual(AUBFixture::getGpuPointer(dstBuffer->getGraphicsAllocation()), srcMemoryToWrite, bufferSize);
+    }
 
     char hostPtrMemory[] = {0, 0, 0, 0, 0, 0, 0, 0};
     ASSERT_EQ(bufferSize, sizeof(hostPtrMemory));
@@ -119,7 +125,9 @@ void AubWriteCopyReadBuffer::runTest() {
         allocation = allocation->next;
     }
 
-    getAubCsr<FamilyType>()->expectMemoryEqual(AUBFixture::getGpuPointer(allocation), srcMemoryToWrite, bufferSize);
+    if (aubCsr) {
+        aubCsr->expectMemoryEqual(AUBFixture::getGpuPointer(allocation), srcMemoryToWrite, bufferSize);
+    }
 }
 
 HWTEST_F(AubWriteCopyReadBuffer, givenTwoBuffersFilledWithPatternWhenSourceIsCopiedToDestinationThenDestinationDataValidates) {
diff --git a/unit_tests/aub_tests/command_stream/aub_command_stream_fixture.cpp b/unit_tests/aub_tests/command_stream/aub_command_stream_fixture.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2017-2018 Intel Corporation
+ * Copyright (C) 2017-2019 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -33,7 +33,7 @@ void AUBCommandStreamFixture::SetUp(CommandQueue *pCmdQ) {
     strfilename << testInfo->test_case_name() << "_" << testInfo->name() << "_" << hwHelper.getCsTraits(engineType.type).name;
 
     if (testMode == TestMode::AubTestsWithTbx) {
-        pCommandStreamReceiver = TbxCommandStreamReceiver::create(hwInfo, true, *device.executionEnvironment);
+        pCommandStreamReceiver = TbxCommandStreamReceiver::create(hwInfo, strfilename.str(), true, *device.executionEnvironment);
     } else {
         pCommandStreamReceiver = AUBCommandStreamReceiver::create(hwInfo, strfilename.str(), true, *device.executionEnvironment);
     }
diff --git a/unit_tests/aub_tests/fixtures/aub_fixture.h b/unit_tests/aub_tests/fixtures/aub_fixture.h
@@ -37,7 +37,7 @@ class AUBFixture : public CommandQueueHwFixture {
 
         executionEnvironment = new ExecutionEnvironment;
         if (testMode == TestMode::AubTestsWithTbx) {
-            this->csr = TbxCommandStreamReceiver::create(hwInfo, true, *executionEnvironment);
+            this->csr = TbxCommandStreamReceiver::create(hwInfo, strfilename.str(), true, *executionEnvironment);
         } else {
             this->csr = AUBCommandStreamReceiver::create(hwInfo, strfilename.str(), true, *executionEnvironment);
         }
@@ -70,13 +70,17 @@ class AUBFixture : public CommandQueueHwFixture {
     template <typename FamilyType>
     void expectMemory(void *gfxAddress, const void *srcAddress, size_t length) {
         auto aubCsr = getAubCsr<FamilyType>();
-        aubCsr->expectMemoryEqual(gfxAddress, srcAddress, length);
+        if (aubCsr) {
+            aubCsr->expectMemoryEqual(gfxAddress, srcAddress, length);
+        }
     }
 
     template <typename FamilyType>
     void expectNotEqualMemory(void *gfxAddress, const void *srcAddress, size_t length) {
         auto aubCsr = getAubCsr<FamilyType>();
-        aubCsr->expectMemoryNotEqual(gfxAddress, srcAddress, length);
+        if (aubCsr) {
+            aubCsr->expectMemoryNotEqual(gfxAddress, srcAddress, length);
+        }
     }
 
     static void *getGpuPointer(GraphicsAllocation *allocation) {
diff --git a/unit_tests/command_stream/command_stream_receiver_with_aub_dump_tests.cpp b/unit_tests/command_stream/command_stream_receiver_with_aub_dump_tests.cpp
@@ -9,10 +9,13 @@
 #include "runtime/command_stream/command_stream_receiver_with_aub_dump.h"
 #include "runtime/command_stream/command_stream_receiver_with_aub_dump.inl"
 #include "runtime/command_stream/preemption.h"
+#include "runtime/command_stream/tbx_command_stream_receiver_hw.h"
 #include "runtime/execution_environment/execution_environment.h"
 #include "runtime/helpers/dispatch_info.h"
 #include "runtime/os_interface/os_context.h"
 #include "unit_tests/mocks/mock_allocation_properties.h"
+#include "unit_tests/mocks/mock_aub_center.h"
+#include "unit_tests/mocks/mock_aub_manager.h"
 
 #include "test.h"
 
@@ -87,7 +90,7 @@ struct MyMockCsr : UltCommandStreamReceiver<DEFAULT_TEST_FAMILY_NAME> {
 
 template <typename BaseCSR>
 struct MyMockCsrWithAubDump : CommandStreamReceiverWithAUBDump<BaseCSR> {
-    MyMockCsrWithAubDump<BaseCSR>(const HardwareInfo &hwInfoIn, bool createAubCSR, ExecutionEnvironment &executionEnvironment) : CommandStreamReceiverWithAUBDump<BaseCSR>(hwInfoIn, executionEnvironment) {
+    MyMockCsrWithAubDump<BaseCSR>(const HardwareInfo &hwInfoIn, bool createAubCSR, ExecutionEnvironment &executionEnvironment) : CommandStreamReceiverWithAUBDump<BaseCSR>(hwInfoIn, "aubfile", executionEnvironment) {
         if (this->aubCSR != nullptr) {
             delete this->aubCSR;
             this->aubCSR = nullptr;
@@ -134,14 +137,36 @@ using CommandStreamReceiverWithAubDumpSimpleTest = ::testing::Test;
 HWTEST_F(CommandStreamReceiverWithAubDumpSimpleTest, givenCsrWithAubDumpWhenSettingOsContextThenReplicateItToAubCsr) {
     ExecutionEnvironment executionEnvironment;
 
-    CommandStreamReceiverWithAUBDump<UltCommandStreamReceiver<FamilyType>> csrWithAubDump(*platformDevices[0], executionEnvironment);
+    CommandStreamReceiverWithAUBDump<UltCommandStreamReceiver<FamilyType>> csrWithAubDump(*platformDevices[0], "aubfile", executionEnvironment);
     OsContext osContext(nullptr, 0, HwHelper::get(platformDevices[0]->pPlatform->eRenderCoreFamily).getGpgpuEngineInstances()[0], PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]));
 
     csrWithAubDump.setupContext(osContext);
     EXPECT_EQ(&osContext, &csrWithAubDump.getOsContext());
     EXPECT_EQ(&osContext, &csrWithAubDump.aubCSR->getOsContext());
 }
 
+HWTEST_F(CommandStreamReceiverWithAubDumpSimpleTest, givenAubManagerAvailaleWhenTbxCsrWithAubDumpIsCreatedThenAubCsrIsNotCreated) {
+    HardwareInfo hwInfo = *platformDevices[0];
+    std::string fileName = "file_name.aub";
+    MockAubManager *mockManager = new MockAubManager();
+    MockAubCenter *mockAubCenter = new MockAubCenter(&hwInfo, false, fileName);
+    mockAubCenter->aubManager = std::unique_ptr<MockAubManager>(mockManager);
+    ExecutionEnvironment executionEnvironment;
+    executionEnvironment.aubCenter = std::unique_ptr<MockAubCenter>(mockAubCenter);
+
+    CommandStreamReceiverWithAUBDump<TbxCommandStreamReceiverHw<FamilyType>> csrWithAubDump(*platformDevices[0], "aubfile", executionEnvironment);
+    ASSERT_EQ(nullptr, csrWithAubDump.aubCSR);
+}
+
+HWTEST_F(CommandStreamReceiverWithAubDumpSimpleTest, givenNullAubManagerAvailaleWhenTbxCsrWithAubDumpIsCreatedThenAubCsrIsCreated) {
+    MockAubCenter *mockAubCenter = new MockAubCenter();
+    ExecutionEnvironment executionEnvironment;
+    executionEnvironment.aubCenter = std::unique_ptr<MockAubCenter>(mockAubCenter);
+
+    CommandStreamReceiverWithAUBDump<TbxCommandStreamReceiverHw<FamilyType>> csrWithAubDump(*platformDevices[0], "aubfile", executionEnvironment);
+    EXPECT_NE(nullptr, csrWithAubDump.aubCSR);
+}
+
 HWTEST_P(CommandStreamReceiverWithAubDumpTest, givenCommandStreamReceiverWithAubDumpWhenCtorIsCalledThenAubCsrIsInitialized) {
     if (createAubCSR) {
         EXPECT_NE(nullptr, csrWithAubDump->aubCSR);
diff --git a/unit_tests/command_stream/tbx_command_stream_fixture.cpp b/unit_tests/command_stream/tbx_command_stream_fixture.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2017-2018 Intel Corporation
+ * Copyright (C) 2017-2019 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -18,7 +18,7 @@ namespace OCLRT {
 void TbxCommandStreamFixture::SetUp(MockDevice *pDevice) {
     // Create our TBX command stream receiver based on HW type
     const auto &hwInfo = pDevice->getHardwareInfo();
-    pCommandStreamReceiver = TbxCommandStreamReceiver::create(hwInfo, false, *pDevice->executionEnvironment);
+    pCommandStreamReceiver = TbxCommandStreamReceiver::create(hwInfo, "", false, *pDevice->executionEnvironment);
     ASSERT_NE(nullptr, pCommandStreamReceiver);
     mmTbx = pCommandStreamReceiver->createMemoryManager(false, false);
     pDevice->resetCommandStreamReceiver(pCommandStreamReceiver);
diff --git a/unit_tests/command_stream/tbx_command_stream_tests.cpp b/unit_tests/command_stream/tbx_command_stream_tests.cpp

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`/*`
`2`		`- * Copyright (C) 2017-2018 Intel Corporation`
	`2`	`+ * Copyright (C) 2017-2019 Intel Corporation`
`3`	`3`	`*`
`4`	`4`	`* SPDX-License-Identifier: MIT`
`5`	`5`	`*`
`@@ -14,7 +14,7 @@ namespace OCLRT {`
`14`	`14`
`15`	`15`	`TbxCommandStreamReceiverCreateFunc tbxCommandStreamReceiverFactory[IGFX_MAX_CORE] = {};`
`16`	`16`
`17`		`-CommandStreamReceiver *TbxCommandStreamReceiver::create(const HardwareInfo &hwInfo, bool withAubDump, ExecutionEnvironment &executionEnvironment) {`
	`17`	`+CommandStreamReceiver *TbxCommandStreamReceiver::create(const HardwareInfo &hwInfo, const std::string &baseName, bool withAubDump, ExecutionEnvironment &executionEnvironment) {`
`18`	`18`
`19`	`19`	`if (hwInfo.pPlatform->eRenderCoreFamily >= IGFX_MAX_CORE) {`
`20`	`20`	`DEBUG_BREAK_IF(!false);`
`@@ -23,6 +23,6 @@ CommandStreamReceiver *TbxCommandStreamReceiver::create(const HardwareInfo &hwIn`
`23`	`23`
`24`	`24`	`auto pCreate = tbxCommandStreamReceiverFactory[hwInfo.pPlatform->eRenderCoreFamily];`
`25`	`25`
`26`		`- return pCreate ? pCreate(hwInfo, withAubDump, executionEnvironment) : nullptr;`
	`26`	`+ return pCreate ? pCreate(hwInfo, baseName, withAubDump, executionEnvironment) : nullptr;`
`27`	`27`	`}`
`28`	`28`	`} // namespace OCLRT`