Debian Codegraph @

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

raw
1 /*
2 * Copyright (c) 2024, 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 //!
23 //! \file vp_render_vebox_update_cmd_packet.cpp
24 //! \brief render packet which used in by mediapipline.
25 //! \details render packet provide the structures and generate the cmd buffer which mediapipline will used.
26 //!
27
28 #include "vp_render_ocl_fc_kernel.h"
29
30 using namespace vp;
31
32 VpRenderOclFcKernel::VpRenderOclFcKernel(PVP_MHWINTERFACE hwInterface, VpKernelID kernelID, uint32_t kernelIndex, PVpAllocator allocator) : VpRenderKernelObj(hwInterface, kernelID, kernelIndex, "", allocator)
33 {
34 m_renderHal = hwInterface ? hwInterface->m_renderHal : nullptr;
35 m_kernelIndex = kernelIndex;
36
37 switch (kernelID)
38 {
39 case kernelOclFcCommon:
40 m_kernelName = "FastComp_fc_common";
41 break;
42 case kernelOclFcFP:
43 m_kernelName = "FastExpress_fc_fp";
44 break;
45 case kernelOclFc444PL3Input:
46 m_kernelName = "ImageRead_fc_444PL3_input";
47 break;
48 case kernelOclFc444PL3Output:
49 m_kernelName = "ImageWrite_fc_444PL3_output";
50 break;
51 case kernelOclFc420PL3Input:
52 m_kernelName = "ImageRead_fc_420PL3_input";
53 break;
54 case kernelOclFc420PL3Output:
55 m_kernelName = "ImageWrite_fc_420PL3_output";
56 break;
57 case kernelOclFc422HVInput:
58 m_kernelName = "ImageRead_fc_422HV_input";
59 break;
60 default:
61 m_kernelName.assign("");
62 VP_RENDER_ASSERTMESSAGE("Kernel ID cannot map to Kernel Name");
63 break;
64 }
65 m_isAdvKernel = true;
66 m_useIndependentSamplerGroup = true;
67 m_kernelBinaryID = VP_ADV_KERNEL_BINARY_ID(kernelID);
68 }
69
70 VpRenderOclFcKernel::~VpRenderOclFcKernel()
71 {
72 MOS_SafeFreeMemory(m_curbe);
73 m_curbe = nullptr;
74 }
75
76 MOS_STATUS VpRenderOclFcKernel::Init(VpRenderKernel &kernel)
77 {
78 VP_FUNC_CALL();
79
80 VP_RENDER_NORMALMESSAGE("Initializing OCL FC krn %s", kernel.GetKernelName().c_str());
81
82 m_kernelSize = kernel.GetKernelSize();
83
84 uint8_t *pKernelBin = (uint8_t *)kernel.GetKernelBinPointer();
85 VP_RENDER_CHK_NULL_RETURN(pKernelBin);
86
87 m_kernelBinary = pKernelBin + kernel.GetKernelBinOffset();
88
89 m_kernelArgs.clear();
90 for (auto &arg : kernel.GetKernelArgs())
91 {
92 arg.pData = nullptr;
93 m_kernelArgs.emplace(arg.uIndex,arg);
94 }
95
96 m_kernelBtis = kernel.GetKernelBtis();
97
98 m_kernelEnv = kernel.GetKernelExeEnv();
99
100 m_curbeLocation.size = kernel.GetCurbeSize();
101
102 m_inlineData.resize(m_kernelEnv.uInlineDataPayloadSize);
103
104 return MOS_STATUS_SUCCESS;
105 }
106
107 MOS_STATUS VpRenderOclFcKernel::SetSamplerStates(KERNEL_SAMPLER_STATE_GROUP &samplerStateGroup)
108 {
109 VP_FUNC_CALL();
110
111 if (m_kernelEnv.bHasSample)
112 {
113 samplerStateGroup.clear();
114
115 MHW_SAMPLER_STATE_PARAM samplerStateParam = {};
116 samplerStateParam.Unorm.SamplerFilterMode = MHW_SAMPLER_FILTER_BILINEAR;
117 samplerStateParam.Unorm.MagFilter = MHW_GFX3DSTATE_MAPFILTER_LINEAR;
118 samplerStateParam.Unorm.MinFilter = MHW_GFX3DSTATE_MAPFILTER_LINEAR;
119 samplerStateParam.Unorm.AddressU = MHW_GFX3DSTATE_TEXCOORDMODE_CLAMP;
120 samplerStateParam.Unorm.AddressV = MHW_GFX3DSTATE_TEXCOORDMODE_CLAMP;
121 samplerStateParam.Unorm.AddressW = MHW_GFX3DSTATE_TEXCOORDMODE_CLAMP;
122 samplerStateParam.bInUse = true;
123 samplerStateParam.SamplerType = MHW_SAMPLER_TYPE_3D;
124 if (m_linearSamplerIndex >= 0)
125 {
126 VP_RENDER_NORMALMESSAGE("Bilinear Sampler Set on Sampler Index %d", m_linearSamplerIndex);
127 samplerStateGroup.emplace(m_linearSamplerIndex, samplerStateParam);
128 }
129 else
130 {
131 VP_RENDER_NORMALMESSAGE("Bilinear Sampler NOT SET for Invalid Index %d", m_linearSamplerIndex);
132 }
133
134 samplerStateParam = {};
135 samplerStateParam.Unorm.SamplerFilterMode = MHW_SAMPLER_FILTER_NEAREST;
136 samplerStateParam.Unorm.MagFilter = MHW_GFX3DSTATE_MAPFILTER_NEAREST;
137 samplerStateParam.Unorm.MinFilter = MHW_GFX3DSTATE_MAPFILTER_NEAREST;
138 samplerStateParam.Unorm.AddressU = MHW_GFX3DSTATE_TEXCOORDMODE_CLAMP;
139 samplerStateParam.Unorm.AddressV = MHW_GFX3DSTATE_TEXCOORDMODE_CLAMP;
140 samplerStateParam.Unorm.AddressW = MHW_GFX3DSTATE_TEXCOORDMODE_CLAMP;
141 samplerStateParam.bInUse = true;
142 samplerStateParam.SamplerType = MHW_SAMPLER_TYPE_3D;
143 if (m_nearestSamplerIndex >= 0)
144 {
145 VP_RENDER_NORMALMESSAGE("Nearest Sampler Set on Sampler Index %d", m_nearestSamplerIndex);
146 samplerStateGroup.emplace(m_nearestSamplerIndex, samplerStateParam);
147 }
148 else
149 {
150 VP_RENDER_NORMALMESSAGE("Nearest Sampler NOT SET for Invalid Index %d", m_nearestSamplerIndex);
151 }
152 }
153
154 return MOS_STATUS_SUCCESS;
155 }
156
157 MOS_STATUS VpRenderOclFcKernel::SetKernelArgs(KERNEL_ARGS &kernelArgs, VP_PACKET_SHARED_CONTEXT *sharedContext)
158 {
159 VP_FUNC_CALL();
160
161 //All pData will be free in VpOclFcFilter::Destroy so no need to free here
162 for (KRN_ARG &srcArg : kernelArgs)
163 {
164 auto handle = m_kernelArgs.find(srcArg.uIndex);
165
166 if (srcArg.eArgKind == ARG_KIND_GENERAL || srcArg.eArgKind == ARG_KIND_INLINE)
167 {
168 if (handle != m_kernelArgs.end())
169 {
170 KRN_ARG &dstArg = handle->second;
171 if (srcArg.pData == nullptr)
172 {
173 VP_RENDER_ASSERTMESSAGE("The Kernel Argument General Data is null! KernelID %d, argIndex %d", m_kernelId, dstArg.uIndex);
174 return MOS_STATUS_INVALID_PARAMETER;
175 }
176 else
177 {
178 dstArg.eArgKind = srcArg.eArgKind;
179 dstArg.pData = srcArg.pData;
180 srcArg.pData = nullptr;
181 }
182 }
183 }
184 else if (srcArg.eArgKind == ARG_KIND_SAMPLER)
185 {
186 if (handle != m_kernelArgs.end())
187 {
188 KRN_ARG &dstArg = handle->second;
189 if (srcArg.pData == nullptr)
190 {
191 VP_RENDER_ASSERTMESSAGE("The Kernel Argument Sampler Data is null! KernelID %d, argIndex %d", m_kernelId, dstArg.uIndex);
192 return MOS_STATUS_INVALID_PARAMETER;
193 }
194 else
195 {
196 if (*(uint32_t *)srcArg.pData == MHW_SAMPLER_FILTER_BILINEAR)
197 {
198 m_linearSamplerIndex = (dstArg.addressMode == AddressingModeBindless) ? 1 : dstArg.uOffsetInPayload;
199 dstArg.pData = (dstArg.addressMode == AddressingModeBindless) ? srcArg.pData : nullptr;
200 srcArg.pData = nullptr;
201 }
202 else if (*(uint32_t *)srcArg.pData == MHW_SAMPLER_FILTER_NEAREST)
203 {
204 m_nearestSamplerIndex = (dstArg.addressMode == AddressingModeBindless) ? 0 : dstArg.uOffsetInPayload;
205 dstArg.pData = (dstArg.addressMode == AddressingModeBindless) ? srcArg.pData : nullptr;
206 srcArg.pData = nullptr;
207 }
208 else
209 {
210 VP_RENDER_ASSERTMESSAGE("The Kernel Argument Sampler Data is INVALID TYPE! KernelID %d, argIndex %d, type %d", m_kernelId, dstArg.uIndex, *(uint32_t *)srcArg.pData);
211 return MOS_STATUS_INVALID_PARAMETER;
212 }
213 }
214 }
215 }
216
217 if (srcArg.pData != nullptr)
218 {
219 srcArg.pData = nullptr;
220 VP_RENDER_ASSERTMESSAGE("The Kernel Argument is set but not used. KernelID %d, argIndex %d", m_kernelId, srcArg.uIndex);
221 }
222 }
223
224 return MOS_STATUS_SUCCESS;
225 }
226
227 MOS_STATUS VpRenderOclFcKernel::GetCurbeState(void *&curbe, uint32_t &curbeLength)
228 {
229 VP_FUNC_CALL();
230 curbeLength = m_curbeLocation.size;
231
232 VP_RENDER_NORMALMESSAGE("KernelID %d, Curbe Size %d\n", m_kernelId, curbeLength);
233
234 if (curbeLength == 0)
235 {
236 return MOS_STATUS_INVALID_PARAMETER;
237 }
238
239 uint8_t *pCurbe = (uint8_t *)MOS_AllocAndZeroMemory(curbeLength);
240 VP_RENDER_CHK_NULL_RETURN(pCurbe);
241 MOS_FreeMemAndSetNull(m_curbe);
242 m_curbe = pCurbe;
243
244 for (auto &handle : m_kernelArgs)
245 {
246 KRN_ARG &arg = handle.second;
247 switch (arg.eArgKind)
248 {
249 case ARG_KIND_GENERAL:
250 if (arg.pData != nullptr)
251 {
252 MOS_SecureMemcpy(pCurbe + arg.uOffsetInPayload, arg.uSize, arg.pData, arg.uSize);
253 VP_RENDER_NORMALMESSAGE("Setting Curbe State KernelID %d, index %d , value %d, argKind %d", m_kernelId, arg.uIndex, *(uint32_t *)arg.pData, arg.eArgKind);
254 }
255 else
256 {
257 VP_RENDER_NORMALMESSAGE("KernelID %d, index %d, argKind %d is empty", m_kernelId, arg.uIndex, arg.eArgKind);
258 }
259 break;
260 case ARG_KIND_SURFACE:
261 if (arg.addressMode == AddressingModeBindless)
262 {
263 // this is bindless surface
264 VP_PUBLIC_CHK_STATUS_RETURN(SetBindlessSurfaceStateToResourceList(arg));
265 VP_RENDER_NORMALMESSAGE("Setting Curbe State Bindless Surface KernelID %d, index %d, argKind %d", m_kernelId, arg.uIndex, arg.eArgKind);
266 }
267 else
268 {
269 if (arg.pData != nullptr)
270 {
271 // this is statelss surface
272 MOS_SecureMemcpy(pCurbe + arg.uOffsetInPayload, arg.uSize, arg.pData, arg.uSize);
273 VP_RENDER_NORMALMESSAGE("Setting Curbe State KernelID %d, index %d , value %d, argKind %d", m_kernelId, arg.uIndex, *(uint32_t *)arg.pData, arg.eArgKind);
274 }
275 else
276 {
277 VP_RENDER_NORMALMESSAGE("KernelID %d, index %d, argKind %d is empty", m_kernelId, arg.uIndex, arg.eArgKind);
278 }
279 }
280 break;
281 case ARG_KIND_INLINE:
282 break;
283 case ARG_KIND_SAMPLER:
284 if (arg.addressMode == AddressingModeBindless)
285 {
286 VP_RENDER_CHK_NULL_RETURN(arg.pData);
287 uint32_t samplerIndex = (*(uint32_t *)arg.pData == MHW_SAMPLER_FILTER_NEAREST) ? 0 : 1;
288 VP_RENDER_CHK_STATUS_RETURN(SetBindlessSamplerToResourceList(arg, samplerIndex));
289 VP_RENDER_NORMALMESSAGE("Setting Curbe State Bindless Sampler KernelID %d, index %d, argKind %d", m_kernelId, arg.uIndex, arg.eArgKind);
290 }
291 break;
292 default:
293 VP_PUBLIC_CHK_STATUS_RETURN(MOS_STATUS_UNIMPLEMENTED);
294 }
295 }
296
297 curbe = pCurbe;
298
299 return MOS_STATUS_SUCCESS;
300 }
301
302 MOS_STATUS VpRenderOclFcKernel::GetKernelSurfaceParam(bool isBTI, SURFACE_PARAMS &surfParam, KERNEL_SURFACE_STATE_PARAM &kernelSurfaceParam)
303 {
304 MOS_ZeroMemory(&kernelSurfaceParam, sizeof(KERNEL_SURFACE_STATE_PARAM));
305 kernelSurfaceParam.surfaceOverwriteParams.updatedRenderSurfaces = true;
306 kernelSurfaceParam.surfaceOverwriteParams.bindedKernel = isBTI;
307 PRENDERHAL_SURFACE_STATE_PARAMS pRenderSurfaceParams = &kernelSurfaceParam.surfaceOverwriteParams.renderSurfaceParams;
308 pRenderSurfaceParams->bAVS = false;
309 pRenderSurfaceParams->Boundary = RENDERHAL_SS_BOUNDARY_ORIGINAL;
310 pRenderSurfaceParams->b2PlaneNV12NeededByKernel = true;
311 pRenderSurfaceParams->forceCommonSurfaceMessage = true;
312 MOS_HW_RESOURCE_DEF resourceType = MOS_HW_RESOURCE_USAGE_VP_INTERNAL_READ_WRITE_RENDER;
313 SurfaceType surfType = surfParam.surfType;
314
315 if (surfParam.combineChannelY)
316 {
317 pRenderSurfaceParams->combineChannelY = true;
318 }
319 pRenderSurfaceParams->isOutput = surfParam.isOutput;
320
321 auto surf = m_surfaceGroup->find(surfType);
322 if (m_surfaceGroup->end() == surf)
323 {
324 VP_RENDER_ASSERTMESSAGE("surf was not found %d", surfType);
325 return MOS_STATUS_NULL_POINTER;
326 }
327 VP_RENDER_CHK_NULL_RETURN(surf->second);
328 VP_RENDER_CHK_NULL_RETURN(surf->second->osSurface);
329
330 pRenderSurfaceParams->MemObjCtl = (m_renderHal->pOsInterface->pfnCachePolicyGetMemoryObject(
331 resourceType,
332 m_renderHal->pOsInterface->pfnGetGmmClientContext(m_renderHal->pOsInterface)))
333 .DwordValue;
334 pRenderSurfaceParams->Component = COMPONENT_VPCommon;
335 if (m_kernelId == kernelOclFcCommon ||
336 m_kernelId == kernelOclFcFP)
337 {
338 kernelSurfaceParam.surfaceOverwriteParams.updatedSurfaceParams = true;
339 kernelSurfaceParam.surfaceOverwriteParams.format = surf->second->osSurface->Format;
340 kernelSurfaceParam.surfaceOverwriteParams.width = MOS_MIN(static_cast<uint16_t>(surf->second->osSurface->dwWidth), static_cast<uint16_t>(surf->second->rcSrc.right));
341 kernelSurfaceParam.surfaceOverwriteParams.height = MOS_MIN(static_cast<uint16_t>(surf->second->osSurface->dwHeight), static_cast<uint16_t>(surf->second->rcSrc.bottom));
342 }
343
344 if (surfParam.needVerticalStirde)
345 {
346 switch (surf->second->SampleType)
347 {
348 case SAMPLE_INTERLEAVED_EVEN_FIRST_TOP_FIELD:
349 case SAMPLE_INTERLEAVED_ODD_FIRST_TOP_FIELD:
350 pRenderSurfaceParams->bVertStride = true;
351 pRenderSurfaceParams->bVertStrideOffs = 0;
352 break;
353 case SAMPLE_INTERLEAVED_EVEN_FIRST_BOTTOM_FIELD:
354 case SAMPLE_INTERLEAVED_ODD_FIRST_BOTTOM_FIELD:
355 pRenderSurfaceParams->bVertStride = true;
356 pRenderSurfaceParams->bVertStrideOffs = 1;
357 break;
358 default:
359 pRenderSurfaceParams->bVertStride = false;
360 pRenderSurfaceParams->bVertStrideOffs = 0;
361 break;
362 }
363 }
364
365 if (surf->second->osSurface->Format == Format_Buffer)
366 {
367 kernelSurfaceParam.surfaceOverwriteParams.updatedSurfaceParams = true;
368 kernelSurfaceParam.surfaceOverwriteParams.bufferResource = true;
369 }
370
371 return MOS_STATUS_SUCCESS;
372 }
373
374 MOS_STATUS VpRenderOclFcKernel::SetupSurfaceState()
375 {
376 VP_FUNC_CALL();
377
378 KERNEL_SURFACE_STATE_PARAM kernelSurfaceParam;
379 m_surfaceState.clear();
380 for (auto it = m_kernelBtis.begin(); it != m_kernelBtis.end(); ++it)
381 {
382 uint32_t argIndex = it->first;
383 uint32_t bti = it->second;
384 auto surfHandle = m_argIndexSurfMap.find(argIndex);
385 VP_PUBLIC_CHK_NOT_FOUND_RETURN(surfHandle, &m_argIndexSurfMap);
386 SURFACE_PARAMS &surfParam = surfHandle->second;
387 SurfaceType surfType = surfParam.surfType;
388
389 if (surfType == SurfaceTypeSubPlane || surfType == SurfaceTypeInvalid)
390 {
391 VP_RENDER_NORMALMESSAGE("Will skip surface argIndex %d, bti %d for its surf type is set as %d", argIndex, bti, surfType);
392 continue;
393 }
394
395 if (m_surfaceState.find(surfType) != m_surfaceState.end())
396 {
397 UpdateCurbeBindingIndex(surfType, bti);
398 continue;
399 }
400
401 VP_PUBLIC_CHK_STATUS_RETURN(GetKernelSurfaceParam(true, surfParam, kernelSurfaceParam));
402
403 m_surfaceState.emplace(surfType, kernelSurfaceParam);
404
405 UpdateCurbeBindingIndex(surfType, bti);
406 }
407 for (auto &handle : m_kernelArgs)
408 {
409 KRN_ARG &arg = handle.second;
410
411 if (arg.addressMode != AddressingModeBindless || arg.eArgKind != ARG_KIND_SURFACE)
412 {
413 continue;
414 }
415 uint32_t argIndex = arg.uIndex;
416 auto surfHandle = m_argIndexSurfMap.find(argIndex);
417 VP_PUBLIC_CHK_NOT_FOUND_RETURN(surfHandle, &m_argIndexSurfMap);
418 SURFACE_PARAMS &surfParam = surfHandle->second;
419 SurfaceType surfType = surfParam.surfType;
420 if (surfParam.planeIndex != 0 || surfType == SurfaceTypeSubPlane || surfType == SurfaceTypeInvalid)
421 {
422 VP_RENDER_NORMALMESSAGE("Will skip bindless surface argIndex %d for its planeIndex is set as %d, surfType %d", argIndex, surfParam.planeIndex, surfType);
423 continue;
424 }
425 if (m_surfaceState.find(surfType) != m_surfaceState.end())
426 {
427 continue;
428 }
429
430 VP_PUBLIC_CHK_STATUS_RETURN(GetKernelSurfaceParam(false, surfParam, kernelSurfaceParam));
431
432 m_surfaceState.insert(std::make_pair(surfType, kernelSurfaceParam));
433 }
434
435 return MOS_STATUS_SUCCESS;
436 }
437
438 MOS_STATUS VpRenderOclFcKernel::GetWalkerSetting(KERNEL_WALKER_PARAMS &walkerParam, KERNEL_PACKET_RENDER_DATA &renderData)
439 {
440 VP_FUNC_CALL();
441
442 if (m_renderHal && m_renderHal->isBindlessHeapInUse)
443 {
444 for (auto &handle : m_kernelArgs)
445 {
446 KRN_ARG &arg = handle.second;
447 if (arg.eArgKind == ARG_KIND_INLINE)
448 {
449 VP_PUBLIC_CHK_STATUS_RETURN(SetInlineDataParameter(arg, m_inlineData.data()));
450 }
451 }
452 }
453
454 walkerParam = m_walkerParam;
455
456 walkerParam.iBindingTable = renderData.bindingTable;
457 walkerParam.iMediaID = renderData.mediaID;
458 walkerParam.iCurbeOffset = renderData.iCurbeOffset;
459 // Should use renderData.iCurbeLength instead of kernelSettings.CURBE_Length.
460 // kernelSettings.CURBE_Length is 32 aligned with 5 bits shift.
461 // renderData.iCurbeLength is RENDERHAL_CURBE_BLOCK_ALIGN(64) aligned.
462 walkerParam.iCurbeLength = renderData.iCurbeLength;
463
464 walkerParam.curbeResourceList = m_curbeResourceList.data();
465 walkerParam.curbeResourceListSize = m_curbeResourceList.size();
466 walkerParam.inlineResourceList = m_inlineResourceList.data();
467 walkerParam.inlineResourceListSize = m_inlineResourceList.size();
468
469 return MOS_STATUS_SUCCESS;
470 }
471
472 // Only for Adv kernels.
473 MOS_STATUS VpRenderOclFcKernel::SetWalkerSetting(KERNEL_THREAD_SPACE &threadSpace, bool bSyncFlag, bool flushL1)
474 {
475 VP_FUNC_CALL();
476 MOS_ZeroMemory(&m_walkerParam, sizeof(KERNEL_WALKER_PARAMS));
477
478 m_walkerParam.iBlocksX = threadSpace.uWidth;
479 m_walkerParam.iBlocksY = threadSpace.uHeight;
480 m_walkerParam.threadWidth = threadSpace.uLocalWidth;
481 m_walkerParam.threadHeight = threadSpace.uLocalHeight;
482 m_walkerParam.threadDepth = 1;
483 m_walkerParam.isVerticalPattern = false;
484 m_walkerParam.bSyncFlag = bSyncFlag;
485
486 m_walkerParam.pipeControlParams.bUpdateNeeded = true;
487 m_walkerParam.pipeControlParams.bEnableDataPortFlush = true;
488 m_walkerParam.pipeControlParams.bUnTypedDataPortCacheFlush = true;
489 m_walkerParam.pipeControlParams.bFlushRenderTargetCache = false;
490 m_walkerParam.pipeControlParams.bInvalidateTextureCache = false;
491
492 if (m_renderHal == nullptr || m_renderHal->isBindlessHeapInUse == false)
493 {
494 for (auto &handle : m_kernelArgs)
495 {
496 KRN_ARG &arg = handle.second;
497 if (arg.eArgKind == ARG_KIND_INLINE)
498 {
499 if (arg.pData != nullptr)
500 {
501 MOS_SecureMemcpy(m_inlineData.data() + arg.uOffsetInPayload, arg.uSize, arg.pData, arg.uSize);
502 VP_RENDER_NORMALMESSAGE("Setting Inline Data KernelID %d, index %d , value %d, argKind %d", m_kernelId, arg.uIndex, *(uint32_t *)arg.pData, arg.eArgKind);
503 }
504 else
505 {
506 VP_RENDER_NORMALMESSAGE("KernelID %d, index %d, argKind %d is empty", m_kernelId, arg.uIndex, arg.eArgKind);
507 }
508 }
509 }
510 }
511 m_walkerParam.inlineDataLength = m_inlineData.size();
512 m_walkerParam.inlineData = m_inlineData.data();
513
514 m_walkerParam.slmSize = m_kernelEnv.uiSlmSize;
515 m_walkerParam.hasBarrier = (m_kernelEnv.uBarrierCount > 0);
516
517 if (m_kernelEnv.uSimdSize != 1)
518 {
519 m_walkerParam.isEmitInlineParameter = true;
520 m_walkerParam.isGenerateLocalID = true;
521 m_walkerParam.emitLocal = MHW_EMIT_LOCAL_XYZ;
522 }
523
524 return MOS_STATUS_SUCCESS;
525 }
526
527 MOS_STATUS VpRenderOclFcKernel::SetKernelConfigs(KERNEL_CONFIGS &kernelConfigs)
528 {
529 VP_FUNC_CALL();
530
531 auto handle = kernelConfigs.find(m_kernelId);
532 VP_PUBLIC_CHK_NOT_FOUND_RETURN(handle, &kernelConfigs);
533
534 OCL_FC_KERNEL_CONFIG *kernelConfig = (OCL_FC_KERNEL_CONFIG *)handle->second;
535 VP_PUBLIC_CHK_NULL_RETURN(kernelConfig);
536
537 m_kernelConfig = *kernelConfig;
538
539 return MOS_STATUS_SUCCESS;
540 }
541
542 MOS_STATUS VpRenderOclFcKernel::SetPerfTag()
543 {
544 auto pOsInterface = m_hwInterface->m_osInterface;
545 VP_RENDER_CHK_NULL_RETURN(pOsInterface);
546 VP_RENDER_CHK_NULL_RETURN(pOsInterface->pfnSetPerfTag);
547
548 pOsInterface->pfnSetPerfTag(pOsInterface, m_kernelConfig.perfTag);
549
550 return MOS_STATUS_SUCCESS;
551 }