Remove dcFlush parameter from finish call

BartoszDunajski · Compute-Runtime-Automation · commit 0337b58ee4f1 · 2019-09-13T12:28:10.000+02:00
Change-Id: Ifc808822399a100745a9d81bb5f6e45903a895fa
Signed-off-by: Dunajski, Bartosz &lt;bartosz.dunajski@intel.com&gt;
diff --git a/runtime/api/api.cpp b/runtime/api/api.cpp
@@ -2045,7 +2045,7 @@ cl_int CL_API_CALL clFinish(cl_command_queue commandQueue) {
     auto pCommandQueue = castToObject<CommandQueue>(commandQueue);
 
     retVal = pCommandQueue
-                 ? pCommandQueue->finish(false)
+                 ? pCommandQueue->finish()
                  : CL_INVALID_COMMAND_QUEUE;
     TRACING_EXIT(clFinish, &retVal);
     return retVal;
diff --git a/runtime/command_queue/command_queue.cpp b/runtime/command_queue/command_queue.cpp
@@ -347,7 +347,7 @@ cl_int CommandQueue::enqueueWriteMemObjForUnmap(MemObj *memObj, void *mappedPtr,
                 mustCallFinish = (CommandQueue::getTaskLevelFromWaitList(this->taskLevel, eventsRequest.numEventsInWaitList, eventsRequest.eventWaitList) != Event::eventNotReady);
             }
             if (mustCallFinish) {
-                finish(true);
+                finish();
             }
         }
     } else {
diff --git a/runtime/command_queue/command_queue.h b/runtime/command_queue/command_queue.h
@@ -308,7 +308,7 @@ class CommandQueue : public BaseObject<_cl_command_queue> {
         return CL_SUCCESS;
     }
 
-    virtual cl_int finish(bool dcFlush) { return CL_SUCCESS; }
+    virtual cl_int finish() { return CL_SUCCESS; }
 
     virtual cl_int flush() { return CL_SUCCESS; }
 
diff --git a/runtime/command_queue/command_queue_hw.h b/runtime/command_queue/command_queue_hw.h
@@ -286,7 +286,7 @@ class CommandQueueHw : public CommandQueue {
                                   const cl_event *eventWaitList,
                                   cl_event *event) override;
 
-    cl_int finish(bool dcFlush) override;
+    cl_int finish() override;
     cl_int flush() override;
 
     template <uint32_t enqueueType>
diff --git a/runtime/command_queue/cpu_data_transfer_handler.cpp b/runtime/command_queue/cpu_data_transfer_handler.cpp
@@ -92,7 +92,7 @@ void *CommandQueue::cpuDataTransferHandler(TransferProperties &transferPropertie
         //wait for the completness of previous commands
         if (transferProperties.cmdType != CL_COMMAND_UNMAP_MEM_OBJECT) {
             if (!transferProperties.memObj->isMemObjZeroCopy() || transferProperties.blocking) {
-                finish(true);
+                finish();
                 eventCompleted = true;
             }
         }
diff --git a/runtime/command_queue/finish.h b/runtime/command_queue/finish.h
@@ -15,7 +15,7 @@
 namespace NEO {
 
 template <typename GfxFamily>
-cl_int CommandQueueHw<GfxFamily>::finish(bool dcFlush) {
+cl_int CommandQueueHw<GfxFamily>::finish() {
     getGpgpuCommandStreamReceiver().flushBatchedSubmissions();
 
     //as long as queue is blocked we need to stall.
diff --git a/runtime/memory_manager/cpu_page_fault_manager_memory_sync.cpp b/runtime/memory_manager/cpu_page_fault_manager_memory_sync.cpp
@@ -20,7 +20,7 @@ void PageFaultManager::transferToGpu(void *ptr, void *cmdQ) {
     auto commandQueue = static_cast<CommandQueue *>(cmdQ);
     auto retVal = commandQueue->enqueueSVMUnmap(ptr, 0, nullptr, nullptr, false);
     UNRECOVERABLE_IF(retVal);
-    retVal = commandQueue->finish(false);
+    retVal = commandQueue->finish();
     UNRECOVERABLE_IF(retVal);
 }
 } // namespace NEO
diff --git a/runtime/os_interface/windows/api_win.cpp b/runtime/os_interface/windows/api_win.cpp
@@ -170,15 +170,15 @@ cl_int CL_API_CALL clEnqueueReleaseDX9ObjectsINTEL(cl_command_queue commandQueue
     for (unsigned int object = 0; object < numObjects; object++) {
         auto memObject = castToObject<MemObj>(memObjects[object]);
         if (!static_cast<D3DSharing<D3DTypesHelper::D3D9> *>(memObject->peekSharingHandler())->isSharedResource()) {
-            cmdQ->finish(true);
+            cmdQ->finish();
             break;
         }
     }
 
     retVal = cmdQ->enqueueReleaseSharedObjects(numObjects, memObjects, numEventsInWaitList,
                                                eventWaitList, event, CL_COMMAND_RELEASE_DX9_OBJECTS_INTEL);
     if (!cmdQ->getContext().getInteropUserSyncEnabled()) {
-        cmdQ->finish(true);
+        cmdQ->finish();
     }
     return retVal;
 }
@@ -264,7 +264,7 @@ cl_int CL_API_CALL clEnqueueReleaseDX9MediaSurfacesKHR(cl_command_queue commandQ
         auto memObject = castToObject<MemObj>(memObjects[object]);
         if (memObject) {
             if (!static_cast<D3DSharing<D3DTypesHelper::D3D9> *>(memObject->peekSharingHandler())->isSharedResource()) {
-                cmdQ->finish(true);
+                cmdQ->finish();
                 break;
             }
 
@@ -277,7 +277,7 @@ cl_int CL_API_CALL clEnqueueReleaseDX9MediaSurfacesKHR(cl_command_queue commandQ
     retVal = cmdQ->enqueueReleaseSharedObjects(numObjects, memObjects, numEventsInWaitList,
                                                eventWaitList, event, CL_COMMAND_RELEASE_DX9_MEDIA_SURFACES_KHR);
     if (!cmdQ->getContext().getInteropUserSyncEnabled()) {
-        cmdQ->finish(true);
+        cmdQ->finish();
     }
     return retVal;
 }
@@ -477,15 +477,15 @@ cl_int CL_API_CALL clEnqueueReleaseD3D10ObjectsKHR(cl_command_queue commandQueue
             return retVal;
         }
         if (!static_cast<D3DSharing<D3DTypesHelper::D3D10> *>(memObject->peekSharingHandler())->isSharedResource()) {
-            cmdQ->finish(true);
+            cmdQ->finish();
             break;
         }
     }
 
     retVal = cmdQ->enqueueReleaseSharedObjects(numObjects, memObjects, numEventsInWaitList,
                                                eventWaitList, event, CL_COMMAND_RELEASE_D3D10_OBJECTS_KHR);
     if (!cmdQ->getContext().getInteropUserSyncEnabled()) {
-        cmdQ->finish(true);
+        cmdQ->finish();
     }
     return retVal;
 }
@@ -682,15 +682,15 @@ cl_int CL_API_CALL clEnqueueReleaseD3D11ObjectsKHR(cl_command_queue commandQueue
             return retVal;
         }
         if (!static_cast<D3DSharing<D3DTypesHelper::D3D11> *>(memObject->peekSharingHandler())->isSharedResource()) {
-            cmdQ->finish(true);
+            cmdQ->finish();
             break;
         }
     }
 
     retVal = cmdQ->enqueueReleaseSharedObjects(numObjects, memObjects, numEventsInWaitList,
                                                eventWaitList, event, CL_COMMAND_RELEASE_D3D11_OBJECTS_KHR);
     if (!cmdQ->getContext().getInteropUserSyncEnabled()) {
-        cmdQ->finish(true);
+        cmdQ->finish();
     }
     return retVal;
 }
diff --git a/runtime/sharings/gl/cl_gl_api.cpp b/runtime/sharings/gl/cl_gl_api.cpp
@@ -273,7 +273,7 @@ cl_int CL_API_CALL clEnqueueReleaseGLObjects(cl_command_queue commandQueue, cl_u
             return retVal;
         }
 
-        pCommandQueue->finish(false);
+        pCommandQueue->finish();
         retVal = pCommandQueue->enqueueReleaseSharedObjects(numObjects, memObjects, numEventsInWaitList, eventWaitList, event,
                                                             CL_COMMAND_RELEASE_GL_OBJECTS);
     }
diff --git a/unit_tests/aub_tests/command_queue/enqueue_read_buffer_rect_aub_tests.cpp b/unit_tests/aub_tests/command_queue/enqueue_read_buffer_rect_aub_tests.cpp
@@ -181,7 +181,7 @@ struct AUBReadBufferRectUnaligned
         AUBCommandStreamFixture::expectMemory<FamilyType>(dstMemoryGPUPtr, referenceMemory, offset);
         AUBCommandStreamFixture::expectMemory<FamilyType>(ptrOffset(dstMemoryGPUPtr, offset), &srcMemory[rowPitch * bufferOrigin[1]], size);
         AUBCommandStreamFixture::expectMemory<FamilyType>(ptrOffset(dstMemoryGPUPtr, size + offset), referenceMemory, bufferSize - offset - size);
-        pCmdQ->finish(true);
+        pCmdQ->finish();
         alignedFree(dstMemory);
     }
 };
diff --git a/unit_tests/aub_tests/command_queue/enqueue_read_image_aub_tests.cpp b/unit_tests/aub_tests/command_queue/enqueue_read_image_aub_tests.cpp
@@ -212,7 +212,7 @@ HWTEST_P(AUBReadImage, simpleUnalignedMemory) {
             ptrOffset(dstMemoryUnaligned, testWidth * testHeight * elementSize);
     }
 
-    retVal = pCmdQ->finish(true); //FixMe - not all test cases verified with expects
+    retVal = pCmdQ->finish(); //FixMe - not all test cases verified with expects
     EXPECT_EQ(CL_SUCCESS, retVal);
 
     alignedFree(dstMemoryAligned);
diff --git a/unit_tests/aub_tests/command_queue/enqueue_read_write_image_aub_fixture.h b/unit_tests/aub_tests/command_queue/enqueue_read_write_image_aub_fixture.h
@@ -115,7 +115,7 @@ struct AUBImageUnaligned
         AUBCommandStreamFixture::expectMemory<FamilyType>(dstMemoryGPUPtr, referenceMemory, offset);
         AUBCommandStreamFixture::expectMemory<FamilyType>(ptrOffset(dstMemoryGPUPtr, offset), &imageMemory[inputRowPitch * origin[1] * pixelSize], size * pixelSize);
         AUBCommandStreamFixture::expectMemory<FamilyType>(ptrOffset(dstMemoryGPUPtr, size * pixelSize + offset), referenceMemory, bufferSize - offset - size * pixelSize);
-        pCmdQ->finish(true);
+        pCmdQ->finish();
         alignedFree(dstMemory);
     }
 
@@ -201,7 +201,7 @@ struct AUBImageUnaligned
             nullptr);
         EXPECT_EQ(CL_SUCCESS, retVal);
 
-        pCmdQ->finish(true);
+        pCmdQ->finish();
 
         auto imageRowPitch = image->getImageDesc().image_row_pitch;
 
diff --git a/unit_tests/aub_tests/command_queue/enqueue_write_buffer_rect_aub_tests.cpp b/unit_tests/aub_tests/command_queue/enqueue_write_buffer_rect_aub_tests.cpp
@@ -171,7 +171,7 @@ struct AUBWriteBufferRectUnaligned
             nullptr);
 
         EXPECT_EQ(CL_SUCCESS, retVal);
-        pCmdQ->finish(true);
+        pCmdQ->finish();
 
         AUBCommandStreamFixture::expectMemory<FamilyType>(pDestMemory, referenceMemory, rowPitch);
         AUBCommandStreamFixture::expectMemory<FamilyType>(pDestMemory + rowPitch * bufferOrigin[1], ptrOffset(srcMemory, offset), size);
diff --git a/unit_tests/aub_tests/gen11/execution_model/enqueue_parent_kernel_tests_gen11.cpp b/unit_tests/aub_tests/gen11/execution_model/enqueue_parent_kernel_tests_gen11.cpp
@@ -98,7 +98,7 @@ GEN11TEST_F(GEN11AUBParentKernelFixture, EnqueueParentKernel) {
 
         pCmdQ->enqueueKernel(pKernel, 1, offset, gws, lws, 0, 0, 0);
 
-        pCmdQ->finish(false);
+        pCmdQ->finish();
 
         uint32_t expectedNumberOfEnqueues = 1;
         uint64_t gpuAddress = devQueue->getQueueBuffer()->getGpuAddress() + offsetof(IGIL_CommandQueue, m_controls.m_TotalNumberOfQueues);
diff --git a/unit_tests/aub_tests/gen8/execution_model/enqueue_parent_kernel_tests_gen8.cpp b/unit_tests/aub_tests/gen8/execution_model/enqueue_parent_kernel_tests_gen8.cpp
@@ -98,7 +98,7 @@ GEN8TEST_F(GEN8AUBParentKernelFixture, EnqueueParentKernel) {
 
         pCmdQ->enqueueKernel(pKernel, 1, offset, gws, lws, 0, 0, 0);
 
-        pCmdQ->finish(false);
+        pCmdQ->finish();
 
         uint32_t expectedNumberOfEnqueues = 1;
         uint64_t gpuAddress = devQueue->getQueueBuffer()->getGpuAddress() + offsetof(IGIL_CommandQueue, m_controls.m_TotalNumberOfQueues);
diff --git a/unit_tests/aub_tests/gen9/execution_model/enqueue_parent_kernel_tests_gen9.cpp b/unit_tests/aub_tests/gen9/execution_model/enqueue_parent_kernel_tests_gen9.cpp
@@ -96,7 +96,7 @@ GEN9TEST_F(AUBParentKernelFixture, EnqueueParentKernel) {
 
         pCmdQ->enqueueKernel(pKernel, 1, offset, gws, lws, 0, 0, 0);
 
-        pCmdQ->finish(false);
+        pCmdQ->finish();
 
         uint32_t expectedNumberOfEnqueues = 1;
         uint64_t gpuAddress = devQueue->getQueueBuffer()->getGpuAddress() + offsetof(IGIL_CommandQueue, m_controls.m_TotalNumberOfQueues);
diff --git a/unit_tests/command_queue/command_queue_hw_tests.cpp b/unit_tests/command_queue/command_queue_hw_tests.cpp
@@ -283,7 +283,7 @@ HWTEST_F(CommandQueueHwTest, GivenNonEmptyQueueOnBlockingMapBufferWillWaitForPre
             : CommandQueueHw<FamilyType>(context, device, 0) {
             finishWasCalled = false;
         }
-        cl_int finish(bool dcFlush) override {
+        cl_int finish() override {
             finishWasCalled = true;
             return 0;
         }
diff --git a/unit_tests/command_queue/command_queue_tests.cpp b/unit_tests/command_queue/command_queue_tests.cpp
@@ -790,7 +790,7 @@ HWTEST_F(WaitForQueueCompletionTests, givenBlockingCallAndBlockedQueueWhenEnqueu
 
 HWTEST_F(WaitForQueueCompletionTests, whenFinishIsCalledThenCallWaitWithoutQuickKmdSleepRequest) {
     std::unique_ptr<MyCmdQueue<FamilyType>> cmdQ(new MyCmdQueue<FamilyType>(context.get(), device.get()));
-    cmdQ->finish(false);
+    cmdQ->finish();
     EXPECT_EQ(1u, cmdQ->waitUntilCompleteCounter);
     EXPECT_FALSE(cmdQ->requestedUseQuickKmdSleep);
 }
diff --git a/unit_tests/command_queue/enqueue_kernel_1_tests.cpp b/unit_tests/command_queue/enqueue_kernel_1_tests.cpp
@@ -617,7 +617,7 @@ HWTEST_F(EnqueueKernelTest, givenCsrInBatchingModeWhenFinishIsCalledThenBatchesS
     pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, nullptr, gws, nullptr, 0, nullptr, nullptr);
     pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, nullptr, gws, nullptr, 0, nullptr, nullptr);
 
-    pCmdQ->finish(false);
+    pCmdQ->finish();
 
     EXPECT_TRUE(mockedSubmissionsAggregator->peekCmdBufferList().peekIsEmpty());
     EXPECT_EQ(1, mockCsr->flushCalledCount);
@@ -637,7 +637,7 @@ HWTEST_F(EnqueueKernelTest, givenCsrInBatchingModeWhenThressEnqueueKernelsAreCal
     pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, nullptr, gws, nullptr, 0, nullptr, nullptr);
     pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, nullptr, gws, nullptr, 0, nullptr, nullptr);
 
-    pCmdQ->finish(false);
+    pCmdQ->finish();
 
     EXPECT_TRUE(mockedSubmissionsAggregator->peekCmdBufferList().peekIsEmpty());
     EXPECT_EQ(1, mockCsr->flushCalledCount);
diff --git a/unit_tests/command_queue/enqueue_kernel_event_tests.cpp b/unit_tests/command_queue/enqueue_kernel_event_tests.cpp
@@ -88,7 +88,7 @@ TEST_F(EventTests, eventWaitShouldntSendPC) {
     // no more tasks after WFE, no need to write PC
     EXPECT_EQ(pEvent->taskLevel + 1, csr.peekTaskLevel());
 
-    pCmdQ->finish(false);
+    pCmdQ->finish();
 
     // Check CL_EVENT_COMMAND_TYPE
     {
@@ -132,7 +132,7 @@ TEST_F(EventTests, waitForArray) {
     EXPECT_EQ(CL_SUCCESS, retVal);
     EXPECT_EQ(pEvent1->taskLevel + 1, csr.peekTaskLevel());
 
-    pCmdQ->finish(false);
+    pCmdQ->finish();
     EXPECT_EQ(pEvent1->taskLevel + 1, csr.peekTaskLevel());
     // Check CL_EVENT_COMMAND_TYPE
     {
@@ -172,7 +172,7 @@ TEST_F(EventTests, event_NDR_Wait_NDR_Finish) {
     ASSERT_EQ(CL_SUCCESS, retVal);
     EXPECT_EQ(pEvent->taskLevel + 2, csr.peekTaskLevel());
 
-    pCmdQ->finish(false);
+    pCmdQ->finish();
     EXPECT_EQ(pEvent->taskLevel + 2, csr.peekTaskLevel());
 
     // Check CL_EVENT_COMMAND_TYPE
diff --git a/unit_tests/command_queue/enqueue_kernel_mt_tests.cpp b/unit_tests/command_queue/enqueue_kernel_mt_tests.cpp
@@ -59,7 +59,7 @@ HWTEST_F(EnqueueKernelTest, givenCsrInBatchingModeWhenFinishIsCalledThenBatchesS
         thread.join();
     }
 
-    pCmdQ->finish(false);
+    pCmdQ->finish();
 
     EXPECT_GE(mockCsr->flushCalledCount, 1);
 
diff --git a/unit_tests/command_queue/enqueue_read_buffer_rect_tests.cpp b/unit_tests/command_queue/enqueue_read_buffer_rect_tests.cpp
@@ -548,7 +548,7 @@ HWTEST_F(EnqueueReadWriteBufferRectDispatch, givenOffsetResultingInMisalignedPtr
     ASSERT_NE(0u, cmdQ->lastEnqueuedKernels.size());
     Kernel *kernel = cmdQ->lastEnqueuedKernels[0];
 
-    cmdQ->finish(true);
+    cmdQ->finish();
 
     parseCommands<FamilyType>(*cmdQ);
 
diff --git a/unit_tests/command_queue/enqueue_thread_tests.cpp b/unit_tests/command_queue/enqueue_thread_tests.cpp
@@ -423,6 +423,6 @@ HWTEST_F(EnqueueThreading, finish) {
     auto csr = (CommandStreamReceiverMock<FamilyType> *)&this->pCmdQ->getGpgpuCommandStreamReceiver();
     csr->expectedToFreeCount = 0u;
 
-    pCmdQ->finish(false);
+    pCmdQ->finish();
 }
 } // namespace ULT
diff --git a/unit_tests/command_queue/enqueue_write_buffer_rect_tests.cpp b/unit_tests/command_queue/enqueue_write_buffer_rect_tests.cpp
@@ -545,7 +545,7 @@ HWTEST_F(EnqueueReadWriteBufferRectDispatch, givenOffsetResultingInMisalignedPtr
     ASSERT_NE(0u, cmdQ->lastEnqueuedKernels.size());
     Kernel *kernel = cmdQ->lastEnqueuedKernels[0];
 
-    cmdQ->finish(true);
+    cmdQ->finish();
 
     parseCommands<FamilyType>(*cmdQ);
 
diff --git a/unit_tests/command_queue/finish_tests.cpp b/unit_tests/command_queue/finish_tests.cpp
@@ -55,7 +55,7 @@ HWTEST_F(FinishTest, ShouldntAddPipeControl_If_CS_greater_than_CQ) {
     commandStreamReceiver.taskLevel = originalCSRLevel; // Must be greater than or equal to HW
     pCmdQ->taskLevel = originalCQLevel;
 
-    auto retVal = pCmdQ->finish(false);
+    auto retVal = pCmdQ->finish();
     ASSERT_EQ(CL_SUCCESS, retVal);
 
     // Don't need to artificially execute PIPE_CONTROL.
@@ -77,7 +77,7 @@ HWTEST_F(FinishTest, ShouldntAddPipeControl_If_CS_greater_than_CQ) {
 HWTEST_F(FinishTest, doesntAddAPipecontrolToCQCommandStream) {
     typedef typename FamilyType::PIPE_CONTROL PIPE_CONTROL;
 
-    auto retVal = pCmdQ->finish(false);
+    auto retVal = pCmdQ->finish();
     ASSERT_EQ(CL_SUCCESS, retVal);
 
     // Check for PIPE_CONTROL
@@ -89,7 +89,7 @@ HWTEST_F(FinishTest, givenFreshQueueWhenFinishIsCalledThenCommandStreamIsNotAllo
     MockContext contextWithMockCmdQ(pDevice, true);
     MockCommandQueueHw<FamilyType> cmdQ(&contextWithMockCmdQ, pDevice, 0);
 
-    auto retVal = cmdQ.finish(false);
+    auto retVal = cmdQ.finish();
     ASSERT_EQ(CL_SUCCESS, retVal);
 
     EXPECT_EQ(nullptr, cmdQ.peekCommandStream());
diff --git a/unit_tests/command_queue/get_size_required_tests.cpp b/unit_tests/command_queue/get_size_required_tests.cpp
@@ -47,7 +47,7 @@ HWTEST_F(GetSizeRequiredTest, finish) {
     auto &commandStream = pCmdQ->getCS(1024);
     auto usedBeforeCS = commandStream.getUsed();
 
-    auto retVal = pCmdQ->finish(false);
+    auto retVal = pCmdQ->finish();
     EXPECT_EQ(CL_SUCCESS, retVal);
 
     EXPECT_EQ(0u, commandStream.getUsed() - usedBeforeCS);
diff --git a/unit_tests/command_queue/oom_tests.cpp b/unit_tests/command_queue/oom_tests.cpp
@@ -73,7 +73,7 @@ HWTEST_P(OOMCommandQueueTest, finish) {
     auto usedBeforeCS = commandStream.getUsed();
     auto usedBeforeISH = indirectHeap.getUsed();
 
-    auto retVal = pCmdQ->finish(false);
+    auto retVal = pCmdQ->finish();
 
     auto usedAfterCS = commandStream.getUsed();
     auto usedAfterISH = indirectHeap.getUsed();
diff --git a/unit_tests/command_stream/command_stream_receiver_flush_task_2_tests.cpp b/unit_tests/command_stream/command_stream_receiver_flush_task_2_tests.cpp
diff --git a/unit_tests/d3d_sharing/d3d_tests_part2.cpp b/unit_tests/d3d_sharing/d3d_tests_part2.cpp
diff --git a/unit_tests/mem_obj/image_release_mapped_ptr_tests.cpp b/unit_tests/mem_obj/image_release_mapped_ptr_tests.cpp
diff --git a/unit_tests/memory_manager/cpu_page_fault_manager_memory_sync_tests.cpp b/unit_tests/memory_manager/cpu_page_fault_manager_memory_sync_tests.cpp
diff --git a/unit_tests/profiling/profiling_tests.cpp b/unit_tests/profiling/profiling_tests.cpp
diff --git a/unit_tests/scenarios/windows/enqueue_read_write_buffer_scenarios_windows_tests.cpp b/unit_tests/scenarios/windows/enqueue_read_write_buffer_scenarios_windows_tests.cpp

Original file line number	Diff line number	Diff line change
`@@ -347,7 +347,7 @@ cl_int CommandQueue::enqueueWriteMemObjForUnmap(MemObj memObj, void mappedPtr,`
`347`	`347`	`mustCallFinish = (CommandQueue::getTaskLevelFromWaitList(this->taskLevel, eventsRequest.numEventsInWaitList, eventsRequest.eventWaitList) != Event::eventNotReady);`
`348`	`348`	`}`
`349`	`349`	`if (mustCallFinish) {`
`350`		`- finish(true);`
	`350`	`+ finish();`
`351`	`351`	`}`
`352`	`352`	`}`
`353`	`353`	`} else {`
Original file line number	Diff line number	Diff line change
`@@ -308,7 +308,7 @@ class CommandQueue : public BaseObject<_cl_command_queue> {`
`308`	`308`	`return CL_SUCCESS;`
`309`	`309`	`}`
`310`	`310`
`311`		`- virtual cl_int finish(bool dcFlush) { return CL_SUCCESS; }`
	`311`	`+ virtual cl_int finish() { return CL_SUCCESS; }`
`312`	`312`
`313`	`313`	`virtual cl_int flush() { return CL_SUCCESS; }`
`314`	`314`
Original file line number	Diff line number	Diff line change
`@@ -92,7 +92,7 @@ void *CommandQueue::cpuDataTransferHandler(TransferProperties &transferPropertie`
`92`	`92`	`//wait for the completness of previous commands`
`93`	`93`	`if (transferProperties.cmdType != CL_COMMAND_UNMAP_MEM_OBJECT) {`
`94`	`94`	`if (!transferProperties.memObj->isMemObjZeroCopy() \|\| transferProperties.blocking) {`
`95`		`- finish(true);`
	`95`	`+ finish();`
`96`	`96`	`eventCompleted = true;`
`97`	`97`	`}`
`98`	`98`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ void PageFaultManager::transferToGpu(void ptr, void cmdQ) {`
`20`	`20`	`auto commandQueue = static_cast<CommandQueue *>(cmdQ);`
`21`	`21`	`auto retVal = commandQueue->enqueueSVMUnmap(ptr, 0, nullptr, nullptr, false);`
`22`	`22`	`UNRECOVERABLE_IF(retVal);`
`23`		`- retVal = commandQueue->finish(false);`
	`23`	`+ retVal = commandQueue->finish();`
`24`	`24`	`UNRECOVERABLE_IF(retVal);`
`25`	`25`	`}`
`26`	`26`	`} // namespace NEO`
Original file line number	Diff line number	Diff line change
`@@ -170,15 +170,15 @@ cl_int CL_API_CALL clEnqueueReleaseDX9ObjectsINTEL(cl_command_queue commandQueue`
`170`	`170`	`for (unsigned int object = 0; object < numObjects; object++) {`
`171`	`171`	`auto memObject = castToObject<MemObj>(memObjects[object]);`
`172`	`172`	`if (!static_cast<D3DSharing<D3DTypesHelper::D3D9> *>(memObject->peekSharingHandler())->isSharedResource()) {`
`173`		`- cmdQ->finish(true);`
	`173`	`+ cmdQ->finish();`
`174`	`174`	`break;`
`175`	`175`	`}`
`176`	`176`	`}`
`177`	`177`
`178`	`178`	`retVal = cmdQ->enqueueReleaseSharedObjects(numObjects, memObjects, numEventsInWaitList,`
`179`	`179`	`eventWaitList, event, CL_COMMAND_RELEASE_DX9_OBJECTS_INTEL);`
`180`	`180`	`if (!cmdQ->getContext().getInteropUserSyncEnabled()) {`
`181`		`- cmdQ->finish(true);`
	`181`	`+ cmdQ->finish();`
`182`	`182`	`}`
`183`	`183`	`return retVal;`
`184`	`184`	`}`
`@@ -264,7 +264,7 @@ cl_int CL_API_CALL clEnqueueReleaseDX9MediaSurfacesKHR(cl_command_queue commandQ`
`264`	`264`	`auto memObject = castToObject<MemObj>(memObjects[object]);`
`265`	`265`	`if (memObject) {`
`266`	`266`	`if (!static_cast<D3DSharing<D3DTypesHelper::D3D9> *>(memObject->peekSharingHandler())->isSharedResource()) {`
`267`		`- cmdQ->finish(true);`
	`267`	`+ cmdQ->finish();`
`268`	`268`	`break;`
`269`	`269`	`}`
`270`	`270`
`@@ -277,7 +277,7 @@ cl_int CL_API_CALL clEnqueueReleaseDX9MediaSurfacesKHR(cl_command_queue commandQ`
`277`	`277`	`retVal = cmdQ->enqueueReleaseSharedObjects(numObjects, memObjects, numEventsInWaitList,`
`278`	`278`	`eventWaitList, event, CL_COMMAND_RELEASE_DX9_MEDIA_SURFACES_KHR);`
`279`	`279`	`if (!cmdQ->getContext().getInteropUserSyncEnabled()) {`
`280`		`- cmdQ->finish(true);`
	`280`	`+ cmdQ->finish();`
`281`	`281`	`}`
`282`	`282`	`return retVal;`
`283`	`283`	`}`
`@@ -477,15 +477,15 @@ cl_int CL_API_CALL clEnqueueReleaseD3D10ObjectsKHR(cl_command_queue commandQueue`
`477`	`477`	`return retVal;`
`478`	`478`	`}`
`479`	`479`	`if (!static_cast<D3DSharing<D3DTypesHelper::D3D10> *>(memObject->peekSharingHandler())->isSharedResource()) {`
`480`		`- cmdQ->finish(true);`
	`480`	`+ cmdQ->finish();`
`481`	`481`	`break;`
`482`	`482`	`}`
`483`	`483`	`}`
`484`	`484`
`485`	`485`	`retVal = cmdQ->enqueueReleaseSharedObjects(numObjects, memObjects, numEventsInWaitList,`
`486`	`486`	`eventWaitList, event, CL_COMMAND_RELEASE_D3D10_OBJECTS_KHR);`
`487`	`487`	`if (!cmdQ->getContext().getInteropUserSyncEnabled()) {`
`488`		`- cmdQ->finish(true);`
	`488`	`+ cmdQ->finish();`
`489`	`489`	`}`
`490`	`490`	`return retVal;`
`491`	`491`	`}`
`@@ -682,15 +682,15 @@ cl_int CL_API_CALL clEnqueueReleaseD3D11ObjectsKHR(cl_command_queue commandQueue`
`682`	`682`	`return retVal;`
`683`	`683`	`}`
`684`	`684`	`if (!static_cast<D3DSharing<D3DTypesHelper::D3D11> *>(memObject->peekSharingHandler())->isSharedResource()) {`
`685`		`- cmdQ->finish(true);`
	`685`	`+ cmdQ->finish();`
`686`	`686`	`break;`
`687`	`687`	`}`
`688`	`688`	`}`
`689`	`689`
`690`	`690`	`retVal = cmdQ->enqueueReleaseSharedObjects(numObjects, memObjects, numEventsInWaitList,`
`691`	`691`	`eventWaitList, event, CL_COMMAND_RELEASE_D3D11_OBJECTS_KHR);`
`692`	`692`	`if (!cmdQ->getContext().getInteropUserSyncEnabled()) {`
`693`		`- cmdQ->finish(true);`
	`693`	`+ cmdQ->finish();`
`694`	`694`	`}`
`695`	`695`	`return retVal;`
`696`	`696`	`}`
Original file line number	Diff line number	Diff line change
`@@ -273,7 +273,7 @@ cl_int CL_API_CALL clEnqueueReleaseGLObjects(cl_command_queue commandQueue, cl_u`
`273`	`273`	`return retVal;`
`274`	`274`	`}`
`275`	`275`
`276`		`- pCommandQueue->finish(false);`
	`276`	`+ pCommandQueue->finish();`
`277`	`277`	`retVal = pCommandQueue->enqueueReleaseSharedObjects(numObjects, memObjects, numEventsInWaitList, eventWaitList, event,`
`278`	`278`	`CL_COMMAND_RELEASE_GL_OBJECTS);`
`279`	`279`	`}`
Original file line number	Diff line number	Diff line change
`@@ -181,7 +181,7 @@ struct AUBReadBufferRectUnaligned`
`181`	`181`	`AUBCommandStreamFixture::expectMemory<FamilyType>(dstMemoryGPUPtr, referenceMemory, offset);`
`182`	`182`	`AUBCommandStreamFixture::expectMemory<FamilyType>(ptrOffset(dstMemoryGPUPtr, offset), &srcMemory[rowPitch * bufferOrigin[1]], size);`
`183`	`183`	`AUBCommandStreamFixture::expectMemory<FamilyType>(ptrOffset(dstMemoryGPUPtr, size + offset), referenceMemory, bufferSize - offset - size);`
`184`		`- pCmdQ->finish(true);`
	`184`	`+ pCmdQ->finish();`
`185`	`185`	`alignedFree(dstMemory);`
`186`	`186`	`}`
`187`	`187`	`};`