1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
|
/*
* Copyright (C) 2019-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/source/command_stream/command_stream_receiver_hw.h"
#include "shared/source/helpers/hw_helper.h"
#include "shared/test/common/cmd_parse/hw_parse.h"
#include "shared/test/common/libult/ult_command_stream_receiver.h"
#include "shared/test/common/mocks/mock_device.h"
#include "shared/test/common/test_macros/hw_test.h"
using namespace NEO;
struct ComputeModeRequirements : public ::testing::Test {
template <typename FamilyType>
struct myCsr : public UltCommandStreamReceiver<FamilyType> {
using CommandStreamReceiver::commandStream;
using CommandStreamReceiver::streamProperties;
myCsr(ExecutionEnvironment &executionEnvironment, const DeviceBitfield deviceBitfield)
: UltCommandStreamReceiver<FamilyType>(executionEnvironment, 0, deviceBitfield){};
CsrSizeRequestFlags *getCsrRequestFlags() { return &this->csrSizeRequestFlags; }
bool hasSharedHandles() override {
if (hasSharedHandlesReturnValue) {
return *hasSharedHandlesReturnValue;
}
return UltCommandStreamReceiver<FamilyType>::hasSharedHandles();
};
std::optional<bool> hasSharedHandlesReturnValue;
};
void makeResidentSharedAlloc() {
csr->getResidencyAllocations().push_back(alloc);
}
template <typename FamilyType>
void overrideComputeModeRequest(bool reqestChanged, bool requireCoherency, bool hasSharedHandles,
bool modifyThreadArbitrationPolicy = false, bool numGrfRequiredChanged = false,
uint32_t numGrfRequired = 128u) {
overrideComputeModeRequest<FamilyType>(reqestChanged, requireCoherency, hasSharedHandles, numGrfRequiredChanged, numGrfRequired);
if (modifyThreadArbitrationPolicy) {
auto &hwHelper = NEO::HwHelper::get(device->getHardwareInfo().platform.eRenderCoreFamily);
auto csrHw = getCsrHw<FamilyType>();
csrHw->streamProperties.stateComputeMode.threadArbitrationPolicy.value = hwHelper.getDefaultThreadArbitrationPolicy();
csrHw->streamProperties.stateComputeMode.threadArbitrationPolicy.isDirty = true;
}
}
template <typename FamilyType>
void overrideComputeModeRequest(bool coherencyRequestChanged,
bool requireCoherency,
bool hasSharedHandles,
bool numGrfRequiredChanged,
uint32_t numGrfRequired) {
auto csrHw = getCsrHw<FamilyType>();
csrHw->hasSharedHandlesReturnValue = hasSharedHandles;
flags.requiresCoherency = requireCoherency;
csrHw->streamProperties.stateComputeMode.isCoherencyRequired.value = requireCoherency;
csrHw->streamProperties.stateComputeMode.isCoherencyRequired.isDirty = coherencyRequestChanged;
csrHw->streamProperties.stateComputeMode.largeGrfMode.value = (numGrfRequired == GrfConfig::LargeGrfNumber);
csrHw->streamProperties.stateComputeMode.largeGrfMode.isDirty = numGrfRequiredChanged;
if (hasSharedHandles) {
makeResidentSharedAlloc();
}
}
template <typename FamilyType>
myCsr<FamilyType> *getCsrHw() {
return static_cast<myCsr<FamilyType> *>(csr);
}
template <typename FamilyType>
void setUpImpl() {
setUpImpl<FamilyType>(defaultHwInfo.get());
}
template <typename FamilyType>
void setUpImpl(const NEO::HardwareInfo *hardwareInfo) {
device.reset(MockDevice::createWithNewExecutionEnvironment<MockDevice>(hardwareInfo));
device->executionEnvironment->rootDeviceEnvironments[0]->setHwInfo(hardwareInfo);
device->executionEnvironment->rootDeviceEnvironments[0]->initGmm();
csr = new myCsr<FamilyType>(*device->executionEnvironment, device->getDeviceBitfield());
device->resetCommandStreamReceiver(csr);
AllocationProperties properties(device->getRootDeviceIndex(), false, MemoryConstants::pageSize, AllocationType::SHARED_BUFFER, false, {});
alloc = device->getMemoryManager()->createGraphicsAllocationFromSharedHandle(static_cast<osHandle>(123), properties, false, false, true);
}
void TearDown() override {
device->getMemoryManager()->freeGraphicsMemory(alloc);
}
CommandStreamReceiver *csr = nullptr;
std::unique_ptr<MockDevice> device;
DispatchFlags flags{{}, nullptr, {}, nullptr, QueueThrottle::MEDIUM, PreemptionMode::Disabled, GrfConfig::DefaultGrfNumber, L3CachingSettings::l3CacheOn, ThreadArbitrationPolicy::NotPresent, AdditionalKernelExecInfo::NotApplicable, KernelExecutionType::NotApplicable, MemoryCompressionState::NotApplicable, QueueSliceCount::defaultSliceCount, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false};
GraphicsAllocation *alloc = nullptr;
};
|
