Media
/
compute-runtime
mirror of https://github.com/intel/compute-runtime.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Remove redundant CommandQueue member 

Change-Id: I2ee338a3134cd81d6de7ecbed47c049dfbbae5aa
Signed-off-by: Dunajski, Bartosz <bartosz.dunajski@intel.com>
This commit is contained in:
Dunajski, Bartosz 2019-12-09 09:15:34 +01:00 committed by sys_ocldev
parent 063df12af0
commit b544b2da60
11 changed files with 28 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
runtime/command_queue/command_queue.h
View File

@ -404,8 +404,6 @@ class CommandQueue : public BaseObject<_cl_command_queue> {
return requiresCacheFlushAfterWalker;
}
bool isMultiEngineQueue() const { return this->multiEngineQueue; }
void updateBcsTaskCount(uint32_t newBcsTaskCount) { this->bcsTaskCount = newBcsTaskCount; }
// taskCount of last task
@ -464,7 +462,6 @@ class CommandQueue : public BaseObject<_cl_command_queue> {
bool isSpecialCommandQueue = false;
bool requiresCacheFlushAfterWalker = false;
bool multiEngineQueue = false;
std::unique_ptr<TimestampPacketContainer> timestampPacketContainer;
};

2
runtime/command_queue/enqueue_common.h
View File

@ -746,7 +746,6 @@ CompletionStamp CommandQueueHw<GfxFamily>::enqueueNonBlocked(
(QueuePriority::LOW == priority), //lowPriority
implicitFlush, //implicitFlush
!eventBuilder.getEvent() || getGpgpuCommandStreamReceiver().isNTo1SubmissionModelEnabled(), //outOfOrderExecutionAllowed
this->multiEngineQueue, //multiEngineQueue
false //epilogueRequired
);
@ -940,7 +939,6 @@ CompletionStamp CommandQueueHw<GfxFamily>::enqueueCommandWithoutKernel(
false, //lowPriority
(enqueueProperties.operation == EnqueueProperties::Operation::Blit), //implicitFlush
getGpgpuCommandStreamReceiver().isNTo1SubmissionModelEnabled(), //outOfOrderExecutionAllowed
multiEngineQueue, //multiEngineQueue
false //epilogueRequired
);

40
runtime/command_stream/csr_definitions.h
View File

@ -49,26 +49,25 @@ struct DispatchFlags {
uint32_t l3CacheSettings, uint64_t sliceCount, bool blocking, bool dcFlush,
bool useSLM, bool guardCommandBufferWithPipeControl, bool gsba32BitRequired,
bool requiresCoherency, bool lowPriority, bool implicitFlush,
bool outOfOrderExecutionAllowed, bool multiEngineQueue, bool epilogueRequired) : csrDependencies(csrDependencies),
barrierTimestampPacketNodes(barrierTimestampPacketNodes),
pipelineSelectArgs(pipelineSelectArgs),
flushStampReference(flushStampReference),
throttle(throttle),
preemptionMode(preemptionMode),
numGrfRequired(numGrfRequired),
l3CacheSettings(l3CacheSettings),
sliceCount(sliceCount),
blocking(blocking),
dcFlush(dcFlush),
useSLM(useSLM),
guardCommandBufferWithPipeControl(guardCommandBufferWithPipeControl),
gsba32BitRequired(gsba32BitRequired),
requiresCoherency(requiresCoherency),
lowPriority(lowPriority),
implicitFlush(implicitFlush),
outOfOrderExecutionAllowed(outOfOrderExecutionAllowed),
multiEngineQueue(multiEngineQueue),
epilogueRequired(epilogueRequired){};
bool outOfOrderExecutionAllowed, bool epilogueRequired) : csrDependencies(csrDependencies),
barrierTimestampPacketNodes(barrierTimestampPacketNodes),
pipelineSelectArgs(pipelineSelectArgs),
flushStampReference(flushStampReference),
throttle(throttle),
preemptionMode(preemptionMode),
numGrfRequired(numGrfRequired),
l3CacheSettings(l3CacheSettings),
sliceCount(sliceCount),
blocking(blocking),
dcFlush(dcFlush),
useSLM(useSLM),
guardCommandBufferWithPipeControl(guardCommandBufferWithPipeControl),
gsba32BitRequired(gsba32BitRequired),
requiresCoherency(requiresCoherency),
lowPriority(lowPriority),
implicitFlush(implicitFlush),
outOfOrderExecutionAllowed(outOfOrderExecutionAllowed),
epilogueRequired(epilogueRequired){};
CsrDependencies csrDependencies;
TimestampPacketContainer *barrierTimestampPacketNodes = nullptr;
PipelineSelectArgs pipelineSelectArgs;
@ -88,7 +87,6 @@ struct DispatchFlags {
bool lowPriority = false;
bool implicitFlush = false;
bool outOfOrderExecutionAllowed = false;
bool multiEngineQueue = false;
bool epilogueRequired = false;
};

3
runtime/helpers/task_information.cpp
View File

@ -68,7 +68,6 @@ CompletionStamp &CommandMapUnmap::submit(uint32_t taskLevel, bool terminated) {
commandQueue.getPriority() == QueuePriority::LOW, //lowPriority
false, //implicitFlush
commandQueue.getGpgpuCommandStreamReceiver().isNTo1SubmissionModelEnabled(), //outOfOrderExecutionAllowed
commandQueue.isMultiEngineQueue(), //multiEngineQueue
false //epilogueRequired
);
@ -223,7 +222,6 @@ CompletionStamp &CommandComputeKernel::submit(uint32_t taskLevel, bool terminate
commandQueue.getPriority() == QueuePriority::LOW, //lowPriority
false, //implicitFlush
commandQueue.getGpgpuCommandStreamReceiver().isNTo1SubmissionModelEnabled(), //outOfOrderExecutionAllowed
commandQueue.isMultiEngineQueue(), //multiEngineQueue
false //epilogueRequired
);
@ -328,7 +326,6 @@ CompletionStamp &CommandWithoutKernel::submit(uint32_t taskLevel, bool terminate
commandQueue.getPriority() == QueuePriority::LOW, //lowPriority
false, //implicitFlush
commandStreamReceiver.isNTo1SubmissionModelEnabled(), //outOfOrderExecutionAllowed
commandQueue.isMultiEngineQueue(), //multiEngineQueue
false //epilogueRequired
);

10
unit_tests/command_queue/command_queue_tests.cpp
View File

@ -433,7 +433,7 @@ HWTEST_F(CommandQueueCommandStreamTest, givenMultiDispatchInfoWithSingleKernelWi
DebugManager.flags.EnableCacheFlushAfterWalker.set(0);
MockCommandQueueHw<FamilyType> cmdQ(context.get(), pDevice, nullptr);
cmdQ.multiEngineQueue = true;
pDevice->getUltCommandStreamReceiver<FamilyType>().multiOsContextCapable = true;
MockKernelWithInternals mockKernelWithInternals(*pDevice, context.get());
mockKernelWithInternals.mockKernel->kernelArgRequiresCacheFlush.resize(1);
@ -1058,14 +1058,6 @@ TEST(CommandQueueDestructorTest, whenCommandQueueIsDestroyedThenDestroysTimestam
EXPECT_EQ(1, context->getRefInternalCount());
}
TEST(CommandQueuePropertiesTests, whenDefaultCommandQueueIsCreatedThenItIsNotMultiEngineQueue) {
MockCommandQueue queue;
EXPECT_FALSE(queue.multiEngineQueue);
EXPECT_FALSE(queue.isMultiEngineQueue());
queue.multiEngineQueue = true;
EXPECT_TRUE(queue.isMultiEngineQueue());
}
TEST(CommandQueuePropertiesTests, whenGetEngineIsCalledThenQueueEngineIsReturned) {
MockCommandQueue queue;
EngineControl engineControl;

1
unit_tests/command_queue/enqueue_command_without_kernel_tests.cpp
View File

@ -126,7 +126,6 @@ HWTEST_F(DispatchFlagsTests, whenEnqueueCommandWithoutKernelThenPassCorrectDispa
EXPECT_EQ(blocking, mockCsr->passedDispatchFlags.blocking);
EXPECT_FALSE(mockCsr->passedDispatchFlags.implicitFlush);
EXPECT_TRUE(mockCsr->passedDispatchFlags.guardCommandBufferWithPipeControl);
EXPECT_EQ(mockCmdQ->isMultiEngineQueue(), mockCsr->passedDispatchFlags.multiEngineQueue);
EXPECT_EQ(device->getPreemptionMode(), mockCsr->passedDispatchFlags.preemptionMode);
EXPECT_EQ(mockCmdQ->flushStamp->getStampReference(), mockCsr->passedDispatchFlags.flushStampReference);
}

14
unit_tests/command_stream/compute_mode_tests.h
View File

@ -16,11 +16,11 @@ using namespace NEO;
struct ComputeModeRequirements : public ::testing::Test {
template <typename FamilyType>
struct myCsr : public CommandStreamReceiverHw<FamilyType> {
struct myCsr : public UltCommandStreamReceiver<FamilyType> {
using CommandStreamReceiver::commandStream;
using CommandStreamReceiverHw<FamilyType>::requiredThreadArbitrationPolicy;
using CommandStreamReceiverHw<FamilyType>::lastSentThreadArbitrationPolicy;
myCsr(ExecutionEnvironment &executionEnvironment) : CommandStreamReceiverHw<FamilyType>(executionEnvironment, 0){};
myCsr(ExecutionEnvironment &executionEnvironment) : UltCommandStreamReceiver<FamilyType>(executionEnvironment, 0){};
CsrSizeRequestFlags *getCsrRequestFlags() { return &this->csrSizeRequestFlags; }
};
void makeResidentSharedAlloc() {
@ -29,12 +29,12 @@ struct ComputeModeRequirements : public ::testing::Test {
template <typename FamilyType>
void overrideComputeModeRequest(bool reqestChanged, bool requireCoherency, bool hasSharedHandles) {
overrideComputeModeRequest<FamilyType>(reqestChanged, requireCoherency, hasSharedHandles, false, 128u, false);
overrideComputeModeRequest<FamilyType>(reqestChanged, requireCoherency, hasSharedHandles, false, 128u);
}
template <typename FamilyType>
void overrideComputeModeRequest(bool reqestChanged, bool requireCoherency, bool hasSharedHandles, bool modifyThreadArbitrationPolicy) {
overrideComputeModeRequest<FamilyType>(reqestChanged, requireCoherency, hasSharedHandles, false, 128u, false);
overrideComputeModeRequest<FamilyType>(reqestChanged, requireCoherency, hasSharedHandles, false, 128u);
if (modifyThreadArbitrationPolicy) {
getCsrHw<FamilyType>()->lastSentThreadArbitrationPolicy = getCsrHw<FamilyType>()->requiredThreadArbitrationPolicy;
}
@ -45,15 +45,13 @@ struct ComputeModeRequirements : public ::testing::Test {
bool requireCoherency,
bool hasSharedHandles,
bool numGrfRequiredChanged,
uint32_t numGrfRequired,
bool multiEngineQueue) {
uint32_t numGrfRequired) {
auto csrHw = getCsrHw<FamilyType>();
csrHw->getCsrRequestFlags()->coherencyRequestChanged = coherencyRequestChanged;
csrHw->getCsrRequestFlags()->hasSharedHandles = hasSharedHandles;
csrHw->getCsrRequestFlags()->numGrfRequiredChanged = numGrfRequiredChanged;
flags.requiresCoherency = requireCoherency;
flags.numGrfRequired = numGrfRequired;
flags.multiEngineQueue = multiEngineQueue;
if (hasSharedHandles) {
makeResidentSharedAlloc();
}
@ -80,6 +78,6 @@ struct ComputeModeRequirements : public ::testing::Test {
CommandStreamReceiver *csr = nullptr;
std::unique_ptr<MockDevice> device;
DispatchFlags flags{{}, nullptr, {}, nullptr, QueueThrottle::MEDIUM, PreemptionMode::Disabled, GrfConfig::DefaultGrfNumber, L3CachingSettings::l3CacheOn, QueueSliceCount::defaultSliceCount, false, false, false, false, false, false, false, false, false, false, false};
DispatchFlags flags{{}, nullptr, {}, nullptr, QueueThrottle::MEDIUM, PreemptionMode::Disabled, GrfConfig::DefaultGrfNumber, L3CachingSettings::l3CacheOn, QueueSliceCount::defaultSliceCount, false, false, false, false, false, false, false, false, false, false};
GraphicsAllocation *alloc = nullptr;
};

4
unit_tests/gen12lp/compute_mode_tests_gen12lp.inl
View File

@ -48,7 +48,7 @@ TGLLPTEST_F(ComputeModeRequirements, givenCsrRequestFlagsWithSharedHandlesWhenCo
EXPECT_EQ(cmdsSize, stream.getUsed());
stream.replaceBuffer(buff, 1024);
overrideComputeModeRequest<FamilyType>(false, false, true, true, 127u, false);
overrideComputeModeRequest<FamilyType>(false, false, true, true, 127u);
retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
EXPECT_EQ(cmdsSize, retSize);
@ -88,7 +88,7 @@ TGLLPTEST_F(ComputeModeRequirements, givenCsrRequestFlagsWithoutSharedHandlesWhe
EXPECT_EQ(cmdsSize, stream.getUsed());
stream.replaceBuffer(buff, 1024);
overrideComputeModeRequest<FamilyType>(false, false, false, true, 127u, false);
overrideComputeModeRequest<FamilyType>(false, false, false, true, 127u);
retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
EXPECT_EQ(cmdsSize, retSize);

1
unit_tests/helpers/dispatch_flags_helper.h
View File

@ -31,7 +31,6 @@ struct DispatchFlagsHelper {
false, //lowPriority
false, //implicitFlush
false, //outOfOrderExecutionAllowed
false, //multiEngineQueue
false //epilogueRequired
);
}

3
unit_tests/helpers/task_information_tests.cpp
View File

@ -199,7 +199,6 @@ HWTEST_F(DispatchFlagsTests, givenCommandMapUnmapWhenSubmitThenPassCorrectDispat
EXPECT_EQ(mockCmdQ->getPriority() == QueuePriority::LOW, mockCsr->passedDispatchFlags.lowPriority);
EXPECT_FALSE(mockCsr->passedDispatchFlags.implicitFlush);
EXPECT_EQ(mockCmdQ->getGpgpuCommandStreamReceiver().isNTo1SubmissionModelEnabled(), mockCsr->passedDispatchFlags.outOfOrderExecutionAllowed);
EXPECT_EQ(mockCmdQ->isMultiEngineQueue(), mockCsr->passedDispatchFlags.multiEngineQueue);
EXPECT_FALSE(mockCsr->passedDispatchFlags.epilogueRequired);
}
@ -248,7 +247,6 @@ HWTEST_F(DispatchFlagsTests, givenCommandComputeKernelWhenSubmitThenPassCorrectD
EXPECT_EQ(mockCmdQ->getPriority() == QueuePriority::LOW, mockCsr->passedDispatchFlags.lowPriority);
EXPECT_FALSE(mockCsr->passedDispatchFlags.implicitFlush);
EXPECT_EQ(mockCmdQ->getGpgpuCommandStreamReceiver().isNTo1SubmissionModelEnabled(), mockCsr->passedDispatchFlags.outOfOrderExecutionAllowed);
EXPECT_EQ(mockCmdQ->isMultiEngineQueue(), mockCsr->passedDispatchFlags.multiEngineQueue);
EXPECT_FALSE(mockCsr->passedDispatchFlags.epilogueRequired);
}
@ -289,7 +287,6 @@ HWTEST_F(DispatchFlagsTests, givenCommandWithoutKernelWhenSubmitThenPassCorrectD
EXPECT_EQ(mockCmdQ->getPriority() == QueuePriority::LOW, mockCsr->passedDispatchFlags.lowPriority);
EXPECT_FALSE(mockCsr->passedDispatchFlags.implicitFlush);
EXPECT_EQ(mockCmdQ->getGpgpuCommandStreamReceiver().isNTo1SubmissionModelEnabled(), mockCsr->passedDispatchFlags.outOfOrderExecutionAllowed);
EXPECT_EQ(mockCmdQ->isMultiEngineQueue(), mockCsr->passedDispatchFlags.multiEngineQueue);
EXPECT_FALSE(mockCsr->passedDispatchFlags.epilogueRequired);
}

2
unit_tests/mocks/mock_command_queue.h
View File

@ -19,7 +19,6 @@ class MockCommandQueue : public CommandQueue {
public:
using CommandQueue::device;
using CommandQueue::gpgpuEngine;
using CommandQueue::multiEngineQueue;
using CommandQueue::obtainNewTimestampPacketNodes;
using CommandQueue::requiresCacheFlushAfterWalker;
using CommandQueue::throttle;
@ -78,7 +77,6 @@ class MockCommandQueueHw : public CommandQueueHw<GfxFamily> {
using BaseClass::bcsTaskCount;
using BaseClass::commandStream;
using BaseClass::gpgpuEngine;
using BaseClass::multiEngineQueue;
using BaseClass::obtainCommandStream;
using BaseClass::obtainNewTimestampPacketNodes;
using BaseClass::requiresCacheFlushAfterWalker;