Debian Codegraph @

media_softlet/agnostic/common/vp/hal/packet/vp_packet_pipe.cpp

raw
1 /*
2 * Copyright (c) 2018-2021, Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included
12 * in all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
21 */
22 #include "vp_cmd_packet.h"
23 #include "vp_utils.h"
24 #include "vp_packet_pipe.h"
25 #include "media_task.h"
26 #include "media_context.h"
27 #include "vp_feature_manager.h"
28 #include "vp_platform_interface.h"
29
30 using namespace vp;
31
32 PacketFactory::PacketFactory(VpPlatformInterface *vpPlatformInterface) : m_vpPlatformInterface(vpPlatformInterface)
33 {
34 }
35
36 PacketFactory::~PacketFactory()
37 {
38 ClearPacketPool(m_VeboxPacketPool);
39 ClearPacketPool(m_RenderPacketPool);
40 MOS_Delete(m_NpuPacket);
41 }
42
43 void PacketFactory::ClearPacketPool(std::vector<VpCmdPacket *> &pool)
44 {
45 VP_FUNC_CALL();
46
47 while (!pool.empty())
48 {
49 VpCmdPacket *p = pool.back();
50 pool.pop_back();
51 MOS_Delete(p);
52 }
53 }
54
55 MOS_STATUS PacketFactory::Initialize(
56 MediaTask *pTask,
57 PVP_MHWINTERFACE pHwInterface,
58 PVpAllocator pAllocator,
59 VPMediaMemComp *pMmc,
60 VP_PACKET_SHARED_CONTEXT *packetSharedContext,
61 VpKernelSet* vpKernels,
62 void *debugInterface,
63 VpGraphSet *vpGraphSets)
64 {
65 VP_FUNC_CALL();
66
67 m_pTask = pTask;
68 m_pHwInterface = pHwInterface;
69 m_pAllocator = pAllocator;
70 m_pMmc = pMmc;
71 m_packetSharedContext = packetSharedContext;
72 m_kernelSet = vpKernels;
73 m_graphSet = vpGraphSets;
74
75 #if (_DEBUG || _RELEASE_INTERNAL)
76 m_debugInterface = static_cast<VpDebugInterface*>(debugInterface);
77 #endif
78
79 return MOS_STATUS_SUCCESS;
80 }
81
82 VpCmdPacket *PacketFactory::CreatePacket(EngineType type)
83 {
84 VP_FUNC_CALL();
85
86 switch(type)
87 {
88 case EngineTypeVebox:
89 case EngineTypeVeboxSfc:
90 if (!m_VeboxPacketPool.empty())
91 {
92 VpCmdPacket *p = m_VeboxPacketPool.back();
93 m_VeboxPacketPool.pop_back();
94 return p;
95 }
96 return CreateVeboxPacket();
97 case EngineTypeRender:
98 if (!m_RenderPacketPool.empty())
99 {
100 VpCmdPacket *p = m_RenderPacketPool.back();
101 m_RenderPacketPool.pop_back();
102 return p;
103 }
104 return CreateRenderPacket();
105 case EngineTypeNpu:
106 if (m_NpuPacket == nullptr)
107 {
108 m_NpuPacket = CreateNpuPacket();
109 }
110 return m_NpuPacket;
111 default:
112 return nullptr;
113 }
114 }
115
116 void PacketFactory::ReturnPacket(VpCmdPacket *&pPacket)
117 {
118 VP_FUNC_CALL();
119
120 if (nullptr == pPacket)
121 {
122 return;
123 }
124 PacketType type = pPacket->GetPacketId();
125 switch (type)
126 {
127 case VP_PIPELINE_PACKET_VEBOX:
128 m_VeboxPacketPool.push_back(pPacket);
129 break;
130 case VP_PIPELINE_PACKET_RENDER:
131 case VP_PIPELINE_PACKET_COMPUTE:
132 m_RenderPacketPool.push_back(pPacket);
133 break;
134 case VP_PIPELINE_PACKET_NPU:
135 //npu packet doesn't have pool. Only one packet is being used and created
136 break;
137 default:
138 break;
139 }
140 pPacket = nullptr;
141 }
142
143 VpCmdPacket *PacketFactory::CreateVeboxPacket()
144 {
145 VP_FUNC_CALL();
146
147 VpCmdPacket *p = m_vpPlatformInterface ? m_vpPlatformInterface->CreateVeboxPacket(m_pTask, m_pHwInterface, m_pAllocator, m_pMmc) : nullptr;
148 if (p)
149 {
150 p->SetPacketSharedContext(m_packetSharedContext);
151 }
152 return p;
153 }
154
155 VpCmdPacket *PacketFactory::CreateRenderPacket()
156 {
157 VP_FUNC_CALL();
158
159 VpCmdPacket *p = m_vpPlatformInterface ? m_vpPlatformInterface->CreateRenderPacket(m_pTask, m_pHwInterface, m_pAllocator, m_pMmc, m_kernelSet) : nullptr;
160 if (p)
161 {
162 MOS_STATUS status = MOS_STATUS_SUCCESS;
163
164 status = p->Init();
165
166 if (MOS_STATUS_SUCCESS != status)
167 {
168 VP_PUBLIC_ASSERTMESSAGE("Render CMD Packet Init Fail");
169 }
170
171 p->SetPacketSharedContext(m_packetSharedContext);
172 }
173 return p;
174 }
175
176 VpCmdPacket* PacketFactory::CreateNpuPacket()
177 {
178 VP_FUNC_CALL();
179
180 VpCmdPacket *p = m_vpPlatformInterface ? m_vpPlatformInterface->CreateNpuPacket(m_pTask, m_pHwInterface, m_pAllocator, m_pMmc, m_graphSet) : nullptr;
181 if (p)
182 {
183 MOS_STATUS status = MOS_STATUS_SUCCESS;
184
185 status = p->Init();
186
187 if (MOS_STATUS_SUCCESS != status)
188 {
189 VP_PUBLIC_ASSERTMESSAGE("NPU CMD Packet Init Fail");
190 }
191
192 p->SetPacketSharedContext(m_packetSharedContext);
193 }
194 return p;
195 }
196
197 PacketPipe::PacketPipe(PacketFactory &packetFactory) : m_PacketFactory(packetFactory)
198 {
199 }
200
201 PacketPipe::~PacketPipe()
202 {
203 Clean();
204 }
205
206 MOS_STATUS PacketPipe::Clean()
207 {
208 VP_FUNC_CALL();
209
210 m_outputPipeMode = VPHAL_OUTPUT_PIPE_MODE_INVALID;
211 m_veboxFeatureInuse = false;
212 for (std::vector<VpCmdPacket *>::iterator it = m_Pipe.begin(); it != m_Pipe.end(); ++it)
213 {
214 m_PacketFactory.ReturnPacket(*it);
215 }
216 m_Pipe.clear();
217 return MOS_STATUS_SUCCESS;
218 }
219
220 MOS_STATUS PacketPipe::AddPacket(HwFilter &hwFilter)
221 {
222 VP_FUNC_CALL();
223
224 VpCmdPacket *pPacket = m_PacketFactory.CreatePacket(hwFilter.GetEngineType());
225 VP_PUBLIC_CHK_NULL_RETURN(pPacket);
226 MOS_STATUS status = hwFilter.SetPacketParams(*pPacket);
227 if (MOS_FAILED(status))
228 {
229 MOS_OS_ASSERTMESSAGE("SetPacketParams failed!");
230 m_PacketFactory.ReturnPacket(pPacket);
231 return status;
232 }
233 m_Pipe.push_back(pPacket);
234 if (hwFilter.GetRenderTargetType() == RenderTargetTypeSurface)
235 {
236 VP_PUBLIC_CHK_STATUS_RETURN(SetOutputPipeMode(hwFilter.GetEngineType()));
237 }
238
239 m_veboxFeatureInuse |= hwFilter.IsVeboxFeatureInuse();
240
241 return MOS_STATUS_SUCCESS;
242 }
243
244 MOS_STATUS PacketPipe::SetOutputPipeMode(EngineType engineType)
245 {
246 VP_FUNC_CALL();
247
248 switch (engineType)
249 {
250 case EngineTypeVebox:
251 m_outputPipeMode = VPHAL_OUTPUT_PIPE_MODE_VEBOX;
252 break;
253 case EngineTypeVeboxSfc:
254 m_outputPipeMode = VPHAL_OUTPUT_PIPE_MODE_SFC;
255 break;
256 case EngineTypeRender:
257 m_outputPipeMode = VPHAL_OUTPUT_PIPE_MODE_COMP;
258 break;
259 case EngineTypeNpu:
260 m_outputPipeMode = VPHAL_OUTPUT_PIPE_MODE_NPU;
261 break;
262 default:
263 m_outputPipeMode = VPHAL_OUTPUT_PIPE_MODE_INVALID;
264 VP_PUBLIC_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
265 }
266
267 return MOS_STATUS_SUCCESS;
268 }
269
270 MOS_STATUS PacketPipe::SwitchContext(PacketType type, MediaScalability *&scalability, MediaContext *mediaContext, bool bEnableVirtualEngine, uint8_t numVebox, uint64_t gpuCtxOnHybridCmd)
271 {
272 VP_FUNC_CALL();
273
274 ScalabilityPars scalPars = {};
275 switch (type)
276 {
277 case VP_PIPELINE_PACKET_VEBOX:
278 {
279 VP_PUBLIC_NORMALMESSAGE("Switch to Vebox Context");
280
281 scalPars.enableVE = bEnableVirtualEngine;
282 scalPars.numVebox = numVebox;
283
284 VP_PUBLIC_CHK_STATUS_RETURN(mediaContext->SwitchContext(VeboxVppFunc, &scalPars, &scalability));
285 VP_PUBLIC_CHK_NULL_RETURN(scalability);
286 break;
287 }
288 case VP_PIPELINE_PACKET_RENDER:
289 {
290 VP_PUBLIC_NORMALMESSAGE("Switch to Render Context");
291 VP_PUBLIC_CHK_STATUS_RETURN(mediaContext->SwitchContext(RenderGenericFunc, &scalPars, &scalability, gpuCtxOnHybridCmd));
292 VP_PUBLIC_CHK_NULL_RETURN(scalability);
293 break;
294 }
295 case VP_PIPELINE_PACKET_COMPUTE:
296 {
297 VP_PUBLIC_NORMALMESSAGE("Switch to Compute Context");
298 VP_PUBLIC_CHK_STATUS_RETURN(mediaContext->SwitchContext(ComputeVppFunc, &scalPars, &scalability, gpuCtxOnHybridCmd));
299 VP_PUBLIC_CHK_NULL_RETURN(scalability);
300 break;
301 }
302 case VP_PIPELINE_PACKET_NPU:
303 {
304 VP_PUBLIC_NORMALMESSAGE("Switch to NPU Context");
305 break;
306 }
307 default:
308 VP_PUBLIC_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
309 }
310 return MOS_STATUS_SUCCESS;
311 }
312
313 MOS_STATUS PacketPipe::Execute(MediaStatusReport *statusReport, MediaScalability *&scalability, MediaContext *mediaContext, bool bEnableVirtualEngine, uint8_t numVebox, uint64_t gpuCtxOnHybridCmd, uint32_t frameCnt)
314 {
315 VP_FUNC_CALL();
316
317 VP_PUBLIC_NORMALMESSAGE("PacketPipe %p in execute.", this);
318
319 // PrePare Packet in case any packet resources shared
320 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
321 for (std::vector<VpCmdPacket*>::reverse_iterator it = m_Pipe.rbegin(); it != m_Pipe.rend(); ++it)
322 {
323 VpCmdPacket* packet = *it;
324 VP_PUBLIC_CHK_STATUS_RETURN(packet->PrepareState());
325 }
326
327 for (std::vector<VpCmdPacket *>::iterator it = m_Pipe.begin(); it != m_Pipe.end(); ++it)
328 {
329 VpCmdPacket *pPacket = *it;
330 PacketProperty prop = {};
331 prop.packetId = pPacket->GetPacketId();
332 prop.packet = pPacket;
333 prop.immediateSubmit = true;
334 prop.stateProperty.statusReport = statusReport;
335
336 bool isSkip = false;
337 // Checking if extra processing is needed.
338 isSkip = pPacket->ExtraProcessing();
339 if (isSkip)
340 {
341 VP_PUBLIC_NORMALMESSAGE("Skip this packet.");
342 continue;
343 }
344
345 MediaTask *pTask = pPacket->GetActiveTask();
346 VP_PUBLIC_CHK_NULL_RETURN(pTask);
347
348 VP_PUBLIC_CHK_STATUS_RETURN(SwitchContext(pPacket->GetPacketId(), scalability, mediaContext, bEnableVirtualEngine, numVebox, gpuCtxOnHybridCmd));
349 VP_PUBLIC_CHK_NULL_RETURN(scalability);
350 pPacket->SetMediaScalability(scalability);
351
352 VP_PUBLIC_CHK_STATUS_RETURN(pTask->AddPacket(&prop));
353 if (prop.immediateSubmit)
354 {
355 VP_PUBLIC_NORMALMESSAGE("Execute Packet %p.", pPacket);
356
357 VP_PUBLIC_CHK_STATUS_RETURN(pTask->Submit(true, scalability, nullptr, pPacket->IsLevelzeroRuntimeInUse()));
358 }
359
360 #if USE_MEDIA_DEBUG_TOOL
361 for (auto& handle : pPacket->GetSurfSetting().surfGroup)
362 {
363 if(handle.first && handle.second)
364 {
365 VP_SURFACE_DUMP(m_PacketFactory.m_debugInterface,
366 handle.second,
367 frameCnt,
368 handle.first,
369 VPHAL_DUMP_TYPE_POST_COMP,
370 VPHAL_SURF_DUMP_DDI_VP_BLT);
371 }
372 }
373 #endif
374 }
375
376 return eStatus;
377 }
378
379 VpCmdPacket *PacketPipe::CreatePacket(EngineType type)
380 {
381 return m_PacketFactory.CreatePacket(type);
382 }
383
384
385 PacketPipeFactory::PacketPipeFactory(PacketFactory &pPacketFactory) : m_pPacketFactory(pPacketFactory)
386 {
387 }
388
389 PacketPipeFactory::~PacketPipeFactory()
390 {
391 while (!m_Pool.empty())
392 {
393 PacketPipe *p = m_Pool.back();
394 m_Pool.pop_back();
395 MOS_Delete(p);
396 }
397 }
398
399 PacketPipe *PacketPipeFactory::CreatePacketPipe()
400 {
401 VP_FUNC_CALL();
402
403 if (!m_Pool.empty())
404 {
405 PacketPipe *p = m_Pool.back();
406 m_Pool.pop_back();
407 p->Clean();
408 return p;
409 }
410 return MOS_New(PacketPipe, m_pPacketFactory);
411 }
412
413 void PacketPipeFactory::ReturnPacketPipe(PacketPipe *&pPipe)
414 {
415 VP_FUNC_CALL();
416
417 if (nullptr == pPipe)
418 {
419 return;
420 }
421 pPipe->Clean();
422 if (std::find(m_Pool.begin(), m_Pool.end(), pPipe) == m_Pool.end())
423 {
424 m_Pool.push_back(pPipe);
425 }
426 else
427 {
428 VP_PUBLIC_ASSERTMESSAGE("packetPipe %p is existing in m_Pool!, m_Pool size is %d.", pPipe, (uint32_t)m_Pool.size());
429 }
430 pPipe = nullptr;
431 }