Debian Codegraph @

shared/test/unit_test/gen11/icllp/test_program_media_sampler_icllp.cpp

raw
1 /*
2 * Copyright (C) 2019-2023 Intel Corporation
3 *
4 * SPDX-License-Identifier: MIT
5 *
6 */
7
8 #include "shared/source/command_stream/command_stream_receiver_hw.h"
9 #include "shared/source/gen11/hw_cmds_icllp.h"
10 #include "shared/source/gen11/reg_configs.h"
11 #include "shared/source/helpers/gfx_core_helper.h"
12 #include "shared/test/common/cmd_parse/hw_parse.h"
13 #include "shared/test/common/helpers/debug_manager_state_restore.h"
14 #include "shared/test/common/helpers/dispatch_flags_helper.h"
15 #include "shared/test/common/mocks/mock_device.h"
16 #include "shared/test/common/test_macros/header/per_product_test_definitions.h"
17 #include "shared/test/common/test_macros/test.h"
18
19 using namespace NEO;
20
21 using PIPE_CONTROL = typename Gen11Family::PIPE_CONTROL;
22 struct Gen11MediaSamplerProgramingTest : public ::testing::Test {
23 typedef typename Gen11Family::MI_LOAD_REGISTER_IMM MI_LOAD_REGISTER_IMM;
24
25 struct MyCsr : public CommandStreamReceiverHw<Gen11Family> {
26 using CommandStreamReceiver::commandStream;
27 using CommandStreamReceiverHw<Gen11Family>::programMediaSampler;
28 MyCsr(ExecutionEnvironment &executionEnvironment) : CommandStreamReceiverHw<Gen11Family>(executionEnvironment, 0, 1){};
29 void overrideLastVmeSubliceConfig(bool value) {
30 lastVmeSubslicesConfig = value;
31 }
32 };
33
34 void overrideMediaRequest(bool lastVmeConfig, bool mediaSamplerRequired) {
35 csr->overrideLastVmeSubliceConfig(lastVmeConfig);
36 flags.pipelineSelectArgs.mediaSamplerRequired = mediaSamplerRequired;
37 }
38
39 void SetUp() override {
40 device.reset(MockDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get()));
41 csr = new MyCsr(*device->executionEnvironment);
42 device->resetCommandStreamReceiver(csr);
43
44 stream.reset(new LinearStream(buff, MemoryConstants::pageSize));
45 }
46
47 void programMediaSampler() {
48 csr->programMediaSampler(*stream, flags);
49 }
50
51 size_t getCmdSize() {
52 return csr->getCmdSizeForMediaSampler(flags.pipelineSelectArgs.mediaSamplerRequired);
53 }
54
55 MyCsr *csr = nullptr;
56 std::unique_ptr<MockDevice> device;
57 DispatchFlags flags = DispatchFlagsHelper::createDefaultDispatchFlags();
58 char buff[MemoryConstants::pageSize];
59 std::unique_ptr<LinearStream> stream;
60 };
61
62 void setFlushAllCaches(PIPE_CONTROL &pc) {
63 pc.setDcFlushEnable(true);
64 pc.setRenderTargetCacheFlushEnable(true);
65 pc.setInstructionCacheInvalidateEnable(true);
66 pc.setTextureCacheInvalidationEnable(true);
67 pc.setPipeControlFlushEnable(true);
68 pc.setVfCacheInvalidationEnable(true);
69 pc.setConstantCacheInvalidationEnable(true);
70 pc.setStateCacheInvalidationEnable(true);
71 }
72
73 ICLLPTEST_F(Gen11MediaSamplerProgramingTest, givenVmeEnableSubsliceDisabledWhenPowerClockStateRegisterEnableThenExpectCorrectCmdValues) {
74 uint32_t programVmeCmdSize = sizeof(MI_LOAD_REGISTER_IMM) + 2 * sizeof(PIPE_CONTROL);
75
76 overrideMediaRequest(false, true);
77
78 size_t estimatedCmdSize = getCmdSize();
79 EXPECT_EQ(programVmeCmdSize, estimatedCmdSize);
80
81 auto expectedMiLrCmd = FamilyType::cmdInitLoadRegisterImm;
82 expectedMiLrCmd.setRegisterOffset(gen11PowerClockStateRegister::address);
83 auto expectedRegValue = (device->getHardwareInfo().gtSystemInfo.SubSliceCount / 2) << gen11PowerClockStateRegister::subSliceCountShift;
84 expectedRegValue |= (gen11PowerClockStateRegister::vmeSliceCount << gen11PowerClockStateRegister::sliceCountShift);
85 expectedRegValue |= (device->getHardwareInfo().gtSystemInfo.MaxEuPerSubSlice << gen11PowerClockStateRegister::minEuCountShift);
86 expectedRegValue |= (device->getHardwareInfo().gtSystemInfo.MaxEuPerSubSlice << gen11PowerClockStateRegister::maxEuCountShift);
87 expectedRegValue |= gen11PowerClockStateRegister::enabledValue;
88 expectedMiLrCmd.setDataDword(expectedRegValue);
89
90 programMediaSampler();
91 ASSERT_EQ(programVmeCmdSize, stream->getUsed());
92
93 auto expectedPipeControlCmd = FamilyType::cmdInitPipeControl;
94 expectedPipeControlCmd.setCommandStreamerStallEnable(0x1);
95 setFlushAllCaches(expectedPipeControlCmd);
96 auto pipeControlCmd = genCmdCast<PIPE_CONTROL *>(stream->getCpuBase());
97 ASSERT_NE(nullptr, pipeControlCmd);
98 EXPECT_EQ(0, memcmp(&expectedPipeControlCmd, pipeControlCmd, sizeof(PIPE_CONTROL)));
99
100 size_t cmdOffset = sizeof(PIPE_CONTROL);
101 auto miLrCmd = genCmdCast<MI_LOAD_REGISTER_IMM *>(ptrOffset(stream->getCpuBase(), cmdOffset));
102 ASSERT_NE(nullptr, miLrCmd);
103 EXPECT_EQ(0, memcmp(&expectedMiLrCmd, miLrCmd, sizeof(MI_LOAD_REGISTER_IMM)));
104
105 cmdOffset += sizeof(MI_LOAD_REGISTER_IMM);
106 expectedPipeControlCmd = FamilyType::cmdInitPipeControl;
107 expectedPipeControlCmd.setCommandStreamerStallEnable(0x1);
108 pipeControlCmd = genCmdCast<PIPE_CONTROL *>(ptrOffset(stream->getCpuBase(), cmdOffset));
109 ASSERT_NE(nullptr, pipeControlCmd);
110 EXPECT_EQ(0, memcmp(&expectedPipeControlCmd, pipeControlCmd, sizeof(PIPE_CONTROL)));
111 }
112
113 ICLLPTEST_F(Gen11MediaSamplerProgramingTest, givenVmeEnableSubsliceEnabledWhenPowerClockStateRegisterDisableThenExpectCorrectCmdValues) {
114 constexpr uint32_t programVmeCmdSize = sizeof(MI_LOAD_REGISTER_IMM) + 3 * sizeof(PIPE_CONTROL);
115
116 overrideMediaRequest(true, false);
117
118 size_t estimatedCmdSize = getCmdSize();
119 EXPECT_EQ(programVmeCmdSize, estimatedCmdSize);
120
121 programMediaSampler();
122
123 auto expectedMiLrCmd = FamilyType::cmdInitLoadRegisterImm;
124 expectedMiLrCmd.setRegisterOffset(gen11PowerClockStateRegister::address);
125 auto expectedRegValue = (device->getHardwareInfo().gtSystemInfo.SubSliceCount / 2) << gen11PowerClockStateRegister::subSliceCountShift;
126 expectedRegValue |= ((device->getHardwareInfo().gtSystemInfo.SliceCount * 2) << gen11PowerClockStateRegister::sliceCountShift);
127 expectedRegValue |= (device->getHardwareInfo().gtSystemInfo.MaxEuPerSubSlice << gen11PowerClockStateRegister::minEuCountShift);
128 expectedRegValue |= (device->getHardwareInfo().gtSystemInfo.MaxEuPerSubSlice << gen11PowerClockStateRegister::maxEuCountShift);
129 expectedRegValue |= gen11PowerClockStateRegister::disabledValue;
130 expectedMiLrCmd.setDataDword(expectedRegValue);
131
132 ASSERT_EQ(programVmeCmdSize, stream->getUsed());
133
134 auto expectedPipeControlCmd = FamilyType::cmdInitPipeControl;
135 expectedPipeControlCmd.setCommandStreamerStallEnable(0x1);
136 setFlushAllCaches(expectedPipeControlCmd);
137 expectedPipeControlCmd.setGenericMediaStateClear(true);
138 auto pipeControlCmd = genCmdCast<PIPE_CONTROL *>(stream->getCpuBase());
139 ASSERT_NE(nullptr, pipeControlCmd);
140 EXPECT_EQ(0, memcmp(&expectedPipeControlCmd, pipeControlCmd, sizeof(PIPE_CONTROL)));
141
142 size_t cmdOffset = sizeof(PIPE_CONTROL);
143 pipeControlCmd = genCmdCast<PIPE_CONTROL *>(ptrOffset(stream->getCpuBase(), cmdOffset));
144 ASSERT_NE(nullptr, pipeControlCmd);
145 expectedPipeControlCmd = FamilyType::cmdInitPipeControl;
146 expectedPipeControlCmd.setCommandStreamerStallEnable(0x1);
147 EXPECT_EQ(0, memcmp(&expectedPipeControlCmd, pipeControlCmd, sizeof(PIPE_CONTROL)));
148
149 cmdOffset += sizeof(PIPE_CONTROL);
150 auto miLrCmd = genCmdCast<MI_LOAD_REGISTER_IMM *>(ptrOffset(stream->getCpuBase(), cmdOffset));
151 ASSERT_NE(nullptr, miLrCmd);
152 EXPECT_EQ(0, memcmp(&expectedMiLrCmd, miLrCmd, sizeof(MI_LOAD_REGISTER_IMM)));
153
154 cmdOffset += sizeof(MI_LOAD_REGISTER_IMM);
155 pipeControlCmd = genCmdCast<PIPE_CONTROL *>(ptrOffset(stream->getCpuBase(), cmdOffset));
156 ASSERT_NE(nullptr, pipeControlCmd);
157 EXPECT_EQ(0, memcmp(&expectedPipeControlCmd, pipeControlCmd, sizeof(PIPE_CONTROL)));
158 }
159
160 ICLLPTEST_F(Gen11MediaSamplerProgramingTest, givenVmeEnableSubsliceEnabledWhenPowerClockStateRegisterEnabledThenExpectNoCmds) {
161 constexpr uint32_t programVmeCmdSize = 0;
162
163 overrideMediaRequest(true, true);
164
165 size_t estimatedCmdSize = getCmdSize();
166 EXPECT_EQ(programVmeCmdSize, estimatedCmdSize);
167
168 programMediaSampler();
169 EXPECT_EQ(programVmeCmdSize, stream->getUsed());
170 }
171
172 ICLLPTEST_F(Gen11MediaSamplerProgramingTest, givenVmeEnableSubsliceDisabledWhenPowerClockStateRegisterDisableThenExpectNoCmds) {
173 constexpr uint32_t programVmeCmdSize = 0;
174
175 overrideMediaRequest(false, false);
176
177 size_t estimatedCmdSize = getCmdSize();
178 EXPECT_EQ(programVmeCmdSize, estimatedCmdSize);
179
180 programMediaSampler();
181 EXPECT_EQ(programVmeCmdSize, stream->getUsed());
182 }