Split CommandStreamReceiver tests into multiple files

Change-Id: Ib114d4da3c94c8a20ff0551d2f9001da7f091000

unit_tests/command_stream/CMakeLists.txt

@@ -26,6 +26,8 @@ set(IGDRCL_SRCS_tests_command_stream
   ${CMAKE_CURRENT_SOURCE_DIR}/command_stream_receiver_hw_tests.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/command_stream_receiver_hw_tests.inl
   ${CMAKE_CURRENT_SOURCE_DIR}/command_stream_receiver_tests.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/command_stream_receiver_flush_task_tests.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/command_stream_receiver_flush_task_gmock_tests.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/command_stream_receiver_with_aub_dump_tests.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/create_command_stream_receiver_tests.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/get_devices_tests.cpp

unit_tests/command_stream/command_stream_receiver_flush_task_gmock_tests.cpp

@@ -0,0 +1,264 @@
+/*
+ * Copyright (c) 2018, Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "reg_configs_common.h"
+#include "runtime/built_ins/built_ins.h"
+#include "runtime/command_queue/command_queue_hw.h"
+#include "runtime/command_stream/command_stream_receiver.h"
+#include "runtime/command_stream/linear_stream.h"
+#include "runtime/os_interface/debug_settings_manager.h"
+#include "runtime/event/user_event.h"
+#include "runtime/helpers/aligned_memory.h"
+#include "runtime/helpers/cache_policy.h"
+#include "runtime/helpers/preamble.h"
+#include "runtime/helpers/ptr_math.h"
+#include "runtime/memory_manager/graphics_allocation.h"
+#include "runtime/memory_manager/memory_manager.h"
+#include "runtime/mem_obj/buffer.h"
+#include "runtime/command_stream/preemption.h"
+#include "unit_tests/libult/ult_command_stream_receiver.h"
+#include "unit_tests/fixtures/device_fixture.h"
+#include "unit_tests/fixtures/built_in_fixture.h"
+#include "unit_tests/fixtures/ult_command_stream_receiver_fixture.h"
+#include "unit_tests/helpers/hw_parse.h"
+#include "unit_tests/helpers/debug_manager_state_restore.h"
+#include "unit_tests/mocks/mock_buffer.h"
+#include "unit_tests/mocks/mock_command_queue.h"
+#include "unit_tests/mocks/mock_context.h"
+#include "unit_tests/mocks/mock_csr.h"
+#include "unit_tests/mocks/mock_event.h"
+#include "unit_tests/mocks/mock_kernel.h"
+#include "unit_tests/mocks/mock_submissions_aggregator.h"
+#include "unit_tests/libult/create_command_stream.h"
+#include "test.h"
+#include "gtest/gtest.h"
+#include "runtime/utilities/linux/debug_env_reader.h"
+#include "runtime/gmm_helper/gmm_helper.h"
+#include "runtime/command_queue/gpgpu_walker.h"
+
+using namespace OCLRT;
+
+using ::testing::_;
+using ::testing::Invoke;
+
+using CommandStreamReceiverFlushTaskGmockTests = UltCommandStreamReceiverTest;
+
+HWTEST_F(CommandStreamReceiverFlushTaskGmockTests, givenCsrInBatchingModeThreeRecordedCommandBufferEnabledBatchBufferFlatteningAndPatchInfoCollectionWhenFlushBatchedSubmissionsIsCalledThenBatchBuffersAndPatchInfoAreCollected) {
+    DebugManagerStateRestore stateRestore;
+    DebugManager.flags.CsrDispatchMode.set(static_cast<uint32_t>(DispatchMode::BatchedDispatch));
+    DebugManager.flags.AddPatchInfoCommentsForAUBDump.set(true);
+    DebugManager.flags.FlattenBatchBufferForAUBDump.set(true);
+
+    typedef typename FamilyType::MI_BATCH_BUFFER_END MI_BATCH_BUFFER_END;
+    typedef typename FamilyType::MI_BATCH_BUFFER_START MI_BATCH_BUFFER_START;
+    typedef typename FamilyType::PIPE_CONTROL PIPE_CONTROL;
+
+    CommandQueueHw<FamilyType> commandQueue(nullptr, pDevice, 0);
+    auto &commandStream = commandQueue.getCS(4096u);
+
+    auto mockCsr = new MockCsrHw2<FamilyType>(*platformDevices[0]);
+    auto mockHelper = new MockFlatBatchBufferHelper<FamilyType>(mockCsr->getMemoryManager());
+    mockCsr->overwriteFlatBatchBufferHelper(mockHelper);
+    pDevice->resetCommandStreamReceiver(mockCsr);
+
+    mockCsr->overrideDispatchPolicy(DispatchMode::BatchedDispatch);
+
+    auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
+    mockCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
+
+    DispatchFlags dispatchFlags;
+    dispatchFlags.guardCommandBufferWithPipeControl = true;
+    dispatchFlags.outOfOrderExecutionAllowed = true;
+
+    EXPECT_CALL(*mockHelper, setPatchInfoData(::testing::_)).Times(10);
+    EXPECT_CALL(*mockHelper, removePatchInfoData(::testing::_)).Times(4 * mockCsr->getRequiredPipeControlSize() / sizeof(PIPE_CONTROL));
+    EXPECT_CALL(*mockHelper, registerCommandChunk(::testing::_)).Times(4);
+    EXPECT_CALL(*mockHelper, registerBatchBufferStartAddress(::testing::_, ::testing::_)).Times(3);
+
+    mockCsr->flushTask(commandStream,
+                       0,
+                       dsh,
+                       ioh,
+                       ssh,
+                       taskLevel,
+                       dispatchFlags);
+
+    mockCsr->flushTask(commandStream,
+                       0,
+                       dsh,
+                       ioh,
+                       ssh,
+                       taskLevel,
+                       dispatchFlags);
+
+    mockCsr->flushTask(commandStream,
+                       0,
+                       dsh,
+                       ioh,
+                       ssh,
+                       taskLevel,
+                       dispatchFlags);
+
+    auto primaryBatch = mockedSubmissionsAggregator->peekCommandBuffers().peekHead();
+    auto lastBatchBuffer = primaryBatch->next->next;
+
+    auto bbEndLocation = primaryBatch->next->batchBufferEndLocation;
+    auto lastBatchBufferAddress = (uint64_t)ptrOffset(lastBatchBuffer->batchBuffer.commandBufferAllocation->getGpuAddress(),
+                                                      lastBatchBuffer->batchBuffer.startOffset);
+
+    mockCsr->flushBatchedSubmissions();
+
+    auto batchBufferStart = genCmdCast<MI_BATCH_BUFFER_START *>(bbEndLocation);
+    ASSERT_NE(nullptr, batchBufferStart);
+    EXPECT_EQ(lastBatchBufferAddress, batchBufferStart->getBatchBufferStartAddressGraphicsaddress472());
+    EXPECT_EQ(1, mockCsr->flushCalledCount);
+}
+
+HWTEST_F(CommandStreamReceiverFlushTaskGmockTests, givenMockCommandStreamerWhenAddPatchInfoCommentsForAUBDumpIsNotSetThenAddPatchInfoDataIsNotCollected) {
+
+    CommandQueueHw<FamilyType> commandQueue(nullptr, pDevice, 0);
+    auto &commandStream = commandQueue.getCS(4096u);
+
+    auto mockCsr = new MockCsrHw2<FamilyType>(*platformDevices[0]);
+    auto mockHelper = new MockFlatBatchBufferHelper<FamilyType>(mockCsr->getMemoryManager());
+    mockCsr->overwriteFlatBatchBufferHelper(mockHelper);
+    pDevice->resetCommandStreamReceiver(mockCsr);
+
+    DispatchFlags dispatchFlags;
+    dispatchFlags.throttle = QueueThrottle::MEDIUM;
+
+    EXPECT_CALL(*mockHelper, setPatchInfoData(_)).Times(0);
+
+    mockCsr->flushTask(commandStream,
+                       0,
+                       dsh,
+                       ioh,
+                       ssh,
+                       taskLevel,
+                       dispatchFlags);
+}
+
+HWTEST_F(CommandStreamReceiverFlushTaskGmockTests, givenMockCommandStreamerWhenAddPatchInfoCommentsForAUBDumpIsSetThenAddPatchInfoDataIsCollected) {
+    DebugManagerStateRestore dbgRestore;
+    DebugManager.flags.AddPatchInfoCommentsForAUBDump.set(true);
+
+    CommandQueueHw<FamilyType> commandQueue(nullptr, pDevice, 0);
+    auto &commandStream = commandQueue.getCS(4096u);
+
+    auto mockCsr = new MockCsrHw2<FamilyType>(*platformDevices[0]);
+    auto mockHelper = new MockFlatBatchBufferHelper<FamilyType>(mockCsr->getMemoryManager());
+    mockCsr->overwriteFlatBatchBufferHelper(mockHelper);
+
+    pDevice->resetCommandStreamReceiver(mockCsr);
+
+    DispatchFlags dispatchFlags;
+    dispatchFlags.throttle = QueueThrottle::MEDIUM;
+
+    std::vector<PatchInfoData> patchInfoDataVector;
+    EXPECT_CALL(*mockHelper, setPatchInfoData(_))
+        .Times(4)
+        .WillRepeatedly(Invoke([&](const PatchInfoData &data) {
+            patchInfoDataVector.push_back(data);
+            return true;
+        }));
+
+    mockCsr->flushTask(commandStream,
+                       0,
+                       dsh,
+                       ioh,
+                       ssh,
+                       taskLevel,
+                       dispatchFlags);
+
+    EXPECT_EQ(4u, patchInfoDataVector.size());
+
+    for (auto &patchInfoData : patchInfoDataVector) {
+        uint64_t expectedAddress = 0u;
+        switch (patchInfoData.sourceType) {
+        case PatchInfoAllocationType::DynamicStateHeap:
+            expectedAddress = dsh.getGraphicsAllocation()->getGpuAddress();
+            break;
+        case PatchInfoAllocationType::SurfaceStateHeap:
+            expectedAddress = ssh.getGraphicsAllocation()->getGpuAddress();
+            break;
+        case PatchInfoAllocationType::IndirectObjectHeap:
+            expectedAddress = ioh.getGraphicsAllocation()->getGpuAddress();
+            break;
+        default:
+            expectedAddress = 0u;
+        }
+        EXPECT_EQ(expectedAddress, patchInfoData.sourceAllocation);
+        EXPECT_EQ(0u, patchInfoData.sourceAllocationOffset);
+        EXPECT_EQ(PatchInfoAllocationType::Default, patchInfoData.targetType);
+    }
+}
+
+HWTEST_F(CommandStreamReceiverFlushTaskGmockTests, givenMockCsrWhenCollectStateBaseAddresPatchInfoIsCalledThenAppropriateAddressesAreTaken) {
+    typedef typename FamilyType::STATE_BASE_ADDRESS STATE_BASE_ADDRESS;
+
+    std::unique_ptr<MockCsrHw2<FamilyType>> mockCsr(new MockCsrHw2<FamilyType>(*platformDevices[0]));
+    auto mockHelper = new MockFlatBatchBufferHelper<FamilyType>(mockCsr->getMemoryManager());
+    mockCsr->overwriteFlatBatchBufferHelper(mockHelper);
+
+    std::vector<PatchInfoData> patchInfoDataVector;
+    EXPECT_CALL(*mockHelper, setPatchInfoData(_))
+        .Times(4)
+        .WillRepeatedly(Invoke([&](const PatchInfoData &data) {
+            patchInfoDataVector.push_back(data);
+            return true;
+        }));
+    EXPECT_CALL(*mockHelper, registerCommandChunk(_))
+        .Times(0);
+
+    uint64_t baseAddress = 0xabcdef;
+    uint64_t commandOffset = 0xa;
+    uint64_t generalStateBase = 0xff;
+
+    mockCsr->collectStateBaseAddresPatchInfo(baseAddress, commandOffset, dsh, ioh, ssh, generalStateBase);
+
+    ASSERT_EQ(patchInfoDataVector.size(), 4u);
+    PatchInfoData dshPatch = patchInfoDataVector[0];
+    PatchInfoData gshPatch = patchInfoDataVector[1];
+    PatchInfoData sshPatch = patchInfoDataVector[2];
+    PatchInfoData iohPatch = patchInfoDataVector[3];
+
+    for (auto &patch : patchInfoDataVector) {
+        EXPECT_EQ(patch.targetAllocation, baseAddress);
+        EXPECT_EQ(patch.sourceAllocationOffset, 0u);
+    }
+
+    //DSH
+    EXPECT_EQ(dshPatch.sourceAllocation, dsh.getGraphicsAllocation()->getGpuAddress());
+    EXPECT_EQ(dshPatch.targetAllocationOffset, commandOffset + STATE_BASE_ADDRESS::PATCH_CONSTANTS::DYNAMICSTATEBASEADDRESS_BYTEOFFSET);
+
+    //IOH
+    EXPECT_EQ(iohPatch.sourceAllocation, ioh.getGraphicsAllocation()->getGpuAddress());
+    EXPECT_EQ(iohPatch.targetAllocationOffset, commandOffset + STATE_BASE_ADDRESS::PATCH_CONSTANTS::INDIRECTOBJECTBASEADDRESS_BYTEOFFSET);
+
+    //SSH
+    EXPECT_EQ(sshPatch.sourceAllocation, ssh.getGraphicsAllocation()->getGpuAddress());
+    EXPECT_EQ(sshPatch.targetAllocationOffset, commandOffset + STATE_BASE_ADDRESS::PATCH_CONSTANTS::SURFACESTATEBASEADDRESS_BYTEOFFSET);
+
+    //GSH
+    EXPECT_EQ(gshPatch.sourceAllocation, generalStateBase);
+    EXPECT_EQ(gshPatch.targetAllocationOffset, commandOffset + STATE_BASE_ADDRESS::PATCH_CONSTANTS::GENERALSTATEBASEADDRESS_BYTEOFFSET);
+}