Debian Codegraph @

media_driver/agnostic/common/cm/cm_device_rt_base.h

raw
1 /*===================== begin_copyright_notice ==================================
2 /*
3 * Copyright (c) 2019, Intel Corporation
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
11 *
12 * The above copyright notice and this permission notice shall be included
13 * in all copies or substantial portions of the Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
16 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
19 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
20 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
21 * OTHER DEALINGS IN THE SOFTWARE.
22 */
23 //!
24 //! \file cm_device_rt_base.h
25 //! \brief Contains CmDeviceRTBase declarations.
26 //!
27
28 #ifndef MEDIADRIVER_COMMON_CM_CMDEVICERT_BASE_H_
29 #define MEDIADRIVER_COMMON_CM_CMDEVICERT_BASE_H_
30
31 #include "cm_device.h"
32
33 #include "cm_array.h"
34 #include "cm_csync.h"
35 #include "cm_hal.h"
36 #include "cm_log.h"
37 #include "cm_program.h"
38 #include "cm_notifier.h"
39
40 #if USE_EXTENSION_CODE
41 #include "cm_gtpin.h"
42 #endif
43
44 namespace CMRT_UMD
45 {
46 class CmSurfaceManager;
47 class CmQueue;
48 class CmQueueRT;
49 class CmKernel;
50 class CmThreadSpace;
51 class CmThreadGroupSpace;
52 class CmVebox;
53 class CmSampler;
54 class CmEvent;
55 class CmTask;
56 class CmQueueBase;
57 class CmProgram;
58 class CmBuffer;
59 class CmBufferUP;
60 class CmBufferSVM;
61 class CmBufferStateless;
62 class CmSurface2D;
63 class CmSurface2DUP;
64 class CmSurface2DUPRT;
65 class CmSurface3D;
66 class CmSampler8x8;
67 class CmSampler8x8State_RT;
68
69 //! \brief CmDevice memory object count
70 struct CM_OBJECT_COUNT
71 {
72 int32_t kernelCount;
73 int32_t programCount;
74 int32_t taskCount;
75 int32_t threadSpaceCount;
76 int32_t threadGroupSpaceCount;
77 int32_t veboxCount;
78 int32_t eventCount;
79 };
80
81
82 //! \brief Class CmDeviceRTBase definitions
83 class CmDeviceRTBase: public CmDevice
84 {
85 public:
86
87 CM_RT_API int32_t CreateBuffer(uint32_t size,
88 CmBuffer* & pSurface);
89
90 CM_RT_API int32_t CreateBuffer(PMOS_RESOURCE pMosResource,
91 CmBuffer* & pSurface);
92
93 CM_RT_API virtual int32_t CreateSurface2D(uint32_t width,
94 uint32_t height,
95 CM_SURFACE_FORMAT format,
96 CmSurface2D* & pSurface) = 0;
97
98 CM_RT_API virtual int32_t CreateSurface2D(PMOS_RESOURCE pMosResource,
99 CmSurface2D* & pSurface) = 0;
100
101 CM_RT_API int32_t CreateSurface3D(uint32_t width,
102 uint32_t height,
103 uint32_t depth,
104 CM_SURFACE_FORMAT format,
105 CmSurface3D* & pSurface);
106
107 CM_RT_API int32_t DestroySurface(CmBuffer* & pSurface);
108
109 CM_RT_API int32_t DestroySurface(CmSurface2D* & pSurface);
110
111 CM_RT_API int32_t DestroySurface(CmSurface3D* & pSurface);
112
113 CM_RT_API int32_t CreateQueue(CmQueue* & pQueue);
114
115 CM_RT_API int32_t LoadProgram(void* pCommonISACode,
116 const uint32_t size,
117 CmProgram*& pProgram,
118 const char* options = nullptr);
119
120 CM_RT_API int32_t CreateKernel(CmProgram* pProgram,
121 const char* kernelName,
122 CmKernel* & pKernel,
123 const char* options = nullptr);
124
125 CM_RT_API virtual int32_t CreateKernel(CmProgram* pProgram,
126 const char* kernelName,
127 const void * fncPnt,
128 CmKernel* & pKernel,
129 const char* options = nullptr)
130 { return CM_NOT_IMPLEMENTED; }
131
132 CM_RT_API int32_t
133 CreateSampler(const CM_SAMPLER_STATE & sampleState,
134 CmSampler* & pSampler);
135
136 CM_RT_API int32_t DestroyKernel(CmKernel*& pKernel);
137
138 CM_RT_API int32_t DestroySampler(CmSampler*& pSampler);
139
140 CM_RT_API int32_t DestroyProgram(CmProgram* & pProgram);
141
142 CM_RT_API int32_t DestroyThreadSpace(CmThreadSpace* & pTS);
143
144 CM_RT_API int32_t CreateTask(CmTask *& pTask);
145
146 CM_RT_API int32_t DestroyTask(CmTask*& pTask);
147
148 CM_RT_API int32_t GetCaps(CM_DEVICE_CAP_NAME capName,
149 uint32_t & capValueSize,
150 void* pCapValue);
151
152 CM_RT_API int32_t CreateThreadSpace(uint32_t width,
153 uint32_t height,
154 CmThreadSpace* & pTS);
155
156 CM_RT_API int32_t CreateBufferUP(uint32_t size,
157 void* pSystMem,
158 CmBufferUP* & pSurface);
159
160 CM_RT_API int32_t DestroyBufferUP(CmBufferUP* & pSurface);
161
162 CM_RT_API int32_t ForceDestroyBufferUP(CmBufferUP* & pSurface);
163
164 CM_RT_API int32_t GetSurface2DInfo(uint32_t width,
165 uint32_t height,
166 CM_SURFACE_FORMAT format,
167 uint32_t & pitch,
168 uint32_t & physicalSize);
169
170 CM_RT_API int32_t CreateSurface2DUP(uint32_t width,
171 uint32_t height,
172 CM_SURFACE_FORMAT format,
173 void* pSysMem,
174 CmSurface2DUP* & pSurface);
175
176 CM_RT_API int32_t DestroySurface2DUP(CmSurface2DUP* & pSurface);
177
178 CM_RT_API int32_t CreateVmeSurfaceG7_5(CmSurface2D* pCurSurface,
179 CmSurface2D** pForwardSurface,
180 CmSurface2D** pBackwardSurface,
181 const uint32_t surfaceCountForward,
182 const uint32_t surfaceCountBackward,
183 SurfaceIndex* & pVmeIndex);
184
185 CM_RT_API int32_t DestroyVmeSurfaceG7_5(SurfaceIndex* & pVmeIndex);
186
187 CM_RT_API int32_t CreateSampler8x8(const CM_SAMPLER_8X8_DESCR & smplDescr,
188 CmSampler8x8 *& psmplrState);
189
190 CM_RT_API int32_t DestroySampler8x8(CmSampler8x8*& ps8x8State);
191
192 CM_RT_API int32_t
193 CreateSampler8x8Surface(CmSurface2D* p2DSurface,
194 SurfaceIndex* & pDIIndex,
195 CM_SAMPLER8x8_SURFACE surf_type,
196 CM_SURFACE_ADDRESS_CONTROL_MODE mode);
197
198 CM_RT_API int32_t DestroySampler8x8Surface(SurfaceIndex* & pDIIndex);
199
200 CM_RT_API int32_t CreateThreadGroupSpace(uint32_t thrdSpaceWidth,
201 uint32_t thrdSpaceHeight,
202 uint32_t grpSpaceWidth,
203 uint32_t grpSpaceHeight,
204 CmThreadGroupSpace*& pTGS);
205
206 CM_RT_API int32_t DestroyThreadGroupSpace(CmThreadGroupSpace*& pTGS);
207
208 CM_RT_API int32_t SetL3Config(const L3ConfigRegisterValues *l3_c);
209
210 CM_RT_API int32_t SetSuggestedL3Config(L3_SUGGEST_CONFIG l3_s_c);
211
212 CM_RT_API int32_t SetCaps(CM_DEVICE_CAP_NAME capName,
213 size_t capValueSize,
214 void* pCapValue);
215
216 CM_RT_API int32_t
217 CreateSamplerSurface2D(CmSurface2D* p2DSurface,
218 SurfaceIndex* & pSamplerSurfaceIndex);
219
220 CM_RT_API int32_t
221 CreateSamplerSurface3D(CmSurface3D* p3DSurface,
222 SurfaceIndex* & pSamplerSurfaceIndex);
223
224 CM_RT_API int32_t
225 DestroySamplerSurface(SurfaceIndex* & pSamplerSurfaceIndex);
226
227 CM_RT_API int32_t
228 InitPrintBuffer(size_t size = CM_DEFAULT_PRINT_BUFFER_SIZE);
229
230 CM_RT_API int32_t FlushPrintBuffer();
231
232 CM_RT_API int32_t CreateVebox(CmVebox* & pVebox);
233
234 CM_RT_API int32_t DestroyVebox(CmVebox* & pVebox);
235
236 CM_RT_API int32_t CreateBufferSVM(uint32_t size,
237 void* & pSystMem,
238 uint32_t access_flag,
239 CmBufferSVM* & pBufferSVM);
240
241 CM_RT_API int32_t DestroyBufferSVM(CmBufferSVM* & pBufferSVM);
242
243 CM_RT_API int32_t
244 CreateSamplerSurface2DUP(CmSurface2DUP* p2DUPSurface,
245 SurfaceIndex* & pSamplerSurfaceIndex);
246
247 CM_RT_API int32_t CloneKernel(CmKernel* &pKernelDest, CmKernel*pKernelSrc);
248
249 CM_RT_API int32_t CreateSurface2DAlias(CmSurface2D* p2DSurface,
250 SurfaceIndex* &aliasSurfaceIndex);
251
252 CM_RT_API int32_t
253 CreateHevcVmeSurfaceG10(CmSurface2D* pCurSurface,
254 CmSurface2D** pForwardSurface,
255 CmSurface2D** pBackwardSurface,
256 const uint32_t surfaceCountForward,
257 const uint32_t surfaceCountBackward,
258 SurfaceIndex* & pVmeIndex);
259
260 CM_RT_API int32_t
261 DestroyHevcVmeSurfaceG10(SurfaceIndex* & pVmeIndex);
262
263 CM_RT_API int32_t CreateSamplerEx(const CM_SAMPLER_STATE_EX & sampleState,
264 CmSampler* & pSampler);
265
266 CM_RT_API int32_t FlushPrintBufferIntoFile(const char *filename);
267
268 CM_RT_API int32_t CreateThreadGroupSpaceEx(uint32_t thrdSpaceWidth,
269 uint32_t thrdSpaceHeight,
270 uint32_t thrdSpaceDepth,
271 uint32_t grpSpaceWidth,
272 uint32_t grpSpaceHeight,
273 uint32_t grpSpaceDepth,
274 CmThreadGroupSpace*& pTGS);
275
276 CM_RT_API int32_t
277 CreateSampler8x8SurfaceEx(
278 CmSurface2D* p2DSurface,
279 SurfaceIndex* & pDIIndex,
280 CM_SAMPLER8x8_SURFACE surf_type = CM_VA_SURFACE,
281 CM_SURFACE_ADDRESS_CONTROL_MODE address_control = CM_SURFACE_CLAMP,
282 CM_FLAG* pFlag = nullptr);
283
284 CM_RT_API int32_t
285 CreateSamplerSurface2DEx(CmSurface2D* p2DSurface,
286 SurfaceIndex* & pSamplerSurfaceIndex,
287 CM_FLAG* pFlag = nullptr);
288
289 CM_RT_API int32_t CreateBufferAlias(CmBuffer *pBuffer,
290 SurfaceIndex* &pAliasIndex);
291
292 CM_RT_API int32_t
293 SetVmeSurfaceStateParam(SurfaceIndex* pVmeIndex,
294 CM_VME_SURFACE_STATE_PARAM *pSSParam);
295
296 CM_RT_API int32_t GetVISAVersion(uint32_t& majorVersion,
297 uint32_t& minorVersion);
298
299 CM_RT_API int32_t
300 CreateQueueEx(CmQueue *&pQueue,
301 CM_QUEUE_CREATE_OPTION QueueCreateOption
302 = CM_DEFAULT_QUEUE_CREATE_OPTION);
303
304 CM_RT_API int32_t UpdateBuffer(PMOS_RESOURCE mosResource, CmBuffer* &surface,
305 MOS_HW_RESOURCE_DEF mosUsage = MOS_CM_RESOURCE_USAGE_SurfaceState);
306
307 CM_RT_API int32_t UpdateSurface2D(PMOS_RESOURCE mosResource, CmSurface2D* &surface,
308 MOS_HW_RESOURCE_DEF mosUsage = MOS_CM_RESOURCE_USAGE_SurfaceState);
309
310 CM_RT_API int32_t
311 CreateSampler8x8SurfaceFromAlias(
312 CmSurface2D *originalSurface,
313 SurfaceIndex *aliasIndex,
314 CM_SURFACE_ADDRESS_CONTROL_MODE addressControl,
315 SurfaceIndex* &sampler8x8SurfaceIndex);
316
317 CM_RT_API int32_t CreateBufferStateless(size_t size,
318 uint32_t option,
319 void *sysMem,
320 CmBufferStateless *&bufferStateless);
321
322 CM_RT_API int32_t DestroyBufferStateless(CmBufferStateless* & bufferStateless);
323
324 void* GetAccelData(){ return m_accelData; }
325
326 MOS_CONTEXT* GetUMDCtx(){ return m_mosContext; }
327
328 uint32_t GetAccelsize(){ return m_accelSize; }
329
330 virtual int32_t GetHalMaxValues(CM_HAL_MAX_VALUES* & pHalMaxValues,
331 CM_HAL_MAX_VALUES_EX* & pHalMaxValuesEx);
332
333 virtual int32_t GetGenPlatform(uint32_t &platform);
334
335 void Sampler8x8CoefficientFormatTransform(
336 CM_AVS_INTERNEL_NONPIPLINED_STATE* dst_avs_state,
337 CM_AVS_NONPIPLINED_STATE* src_avs_state);
338
339 virtual int32_t GetSurfaceManager(CmSurfaceManager* &pSurfaceMgr);
340
341 virtual std::vector<CmQueueRT *> &GetQueue();
342
343 virtual CSync* GetSurfaceLock();
344
345 virtual CSync* GetSurfaceCreationLock();
346
347 virtual CSync* GetProgramKernelLock();
348
349 virtual CSync* GetQueueLock();
350
351 virtual int32_t LoadPredefinedCopyKernel(CmProgram*& pProgram);
352
353 virtual int32_t LoadPredefinedInitKernel(CmProgram*& pProgram);
354
355 int32_t GetKernelSlot()
356 {
357 return m_kernelArray.GetFirstFreeIndex();
358 }
359
360 int32_t PrepareGPUinitSurface();
361
362 virtual int32_t GPUinitSurface(CmSurface2D* surf2D, const uint32_t initValue, CmEvent*& event);
363 virtual bool CheckGTPinEnabled();
364
365 #if USE_EXTENSION_CODE
366 int32_t EnableGTPin(CmBufferUP* pBufferUP0,
367 CmBufferUP* pBufferUP1,
368 CmBufferUP* pBufferUP2,
369 char * pGTPinCom,
370 GTPIN_INVOKE_STRUCT* pInvokeStruct,
371 bool reserveRegisters);
372 virtual CmGTPin *GetGTPin();
373 #endif
374
375 virtual int32_t GetGenStepInfo(char*& stepinfostr);
376
377 int32_t GetCapsInternal(void *pCaps, uint32_t *puSize);
378
379 int32_t Acquire();
380
381 int32_t Release();
382
383 virtual int32_t GetPrintBufferIndex(SurfaceIndex *& pIndex) const;
384
385 virtual bool IsPrintEnable() const;
386
387 virtual bool IsVtuneLogOn() const;
388
389 int32_t GetPrintBufferMem(unsigned char *& pPrintBufferMem) const;
390
391 int32_t GetSurf2DLookUpEntry(uint32_t index,
392 PCMLOOKUP_ENTRY &pLookupEntry);
393
394 int32_t DestroySurfaceInPool(uint32_t &freeSurfNum);
395
396 virtual int32_t CreateSurface2D(PMOS_RESOURCE pMosResource,
397 bool bIsCmCreated,
398 CmSurface2D* & pSurface) = 0;
399
400 virtual int32_t GetSampler8x8(uint32_t index, CmSampler8x8State_RT *&pSampler8x8);
401
402 virtual bool IsScratchSpaceDisabled();
403
404 int32_t SetSurfaceArraySizeForAlias();
405
406 uint32_t GetDriverStoreFlag() { return m_isDriverStoreEnabled; }
407
408 void SetDriverStoreFlag(uint32_t dsEnabled)
409 {
410 m_isDriverStoreEnabled = dsEnabled;
411 }
412
413 virtual CmDynamicArray* GetKernelArray();
414
415 virtual uint32_t *GetKernelCount();
416
417 #if CM_LOG_ON
418 std::string Log();
419 #endif
420 virtual CM_HAL_STATE* GetHalState();
421
422 int32_t DestroyVmeSurface(SurfaceIndex *& pVmeIndex);
423
424 virtual int32_t CreatePrintBuffer();
425
426 CmNotifierGroup* GetNotifiers() {return m_notifierGroup;}
427
428 CM_HAL_CREATE_PARAM &GetCmHalCreateOption() {return m_cmHalCreateOption;}
429
430 inline bool HasGpuCopyKernel() {return m_hasGpuCopyKernel; }
431
432 inline bool HasGpuInitKernel() {return m_hasGpuInitKernel; }
433
434 // Num of kernels included in CmProgram Loaded by this device
435 inline uint32_t& KernelsLoaded() {return m_kernelsLoaded; }
436
437 virtual int32_t GetJITCompileFnt(pJITCompile &fJITCompile) = 0;
438
439 virtual int32_t GetJITCompileFntV2(pJITCompile_v2 &fJITCompile_v2) = 0;
440
441 virtual int32_t GetFreeBlockFnt(pFreeBlock &fFreeBlock) = 0;
442
443 virtual int32_t GetJITVersionFnt(pJITVersion &fJITVersion) = 0;
444
445 virtual int32_t LoadJITDll() = 0;
446
447 virtual HANDLE QueryRegHandleInternal(PCM_HAL_STATE pCmHalState) = 0;
448
449 CM_OBJECT_COUNT m_memObjectCount;
450
451 int32_t CheckObjectCount();
452
453 protected:
454 int32_t Initialize(MOS_CONTEXT *pUmdContext);
455
456 int32_t DestroyQueue(CmQueueRT* & pQueue);
457
458 int32_t RegisterSamplerState(const CM_SAMPLER_STATE& sampleState,
459 uint32_t& index);
460
461 int32_t RegisterSamplerStateEx(const CM_SAMPLER_STATE_EX& sampleState,
462 uint32_t& index);
463
464 int32_t UnregisterSamplerState(uint32_t index);
465
466 int32_t RegisterSampler8x8State(const CM_SAMPLER_8X8_DESCR & sampler8x8State,
467 uint32_t& index);
468
469 int32_t UnregisterSampler8x8State(uint32_t index);
470
471 int32_t GetMaxValueFromCaps(CM_HAL_MAX_VALUES &MaxValues,
472 CM_HAL_MAX_VALUES_EX &MaxValuesEx);
473
474 int32_t InitDevCreateOption(CM_HAL_CREATE_PARAM & DevCreateParam,
475 uint32_t DevCreateOption);
476
477 CmDeviceRTBase(uint32_t DevCreateOption);
478
479 ~CmDeviceRTBase()
480 {
481 if (m_notifierGroup != nullptr)
482 {
483 delete m_notifierGroup;
484 }
485 }
486
487 void DestructCommon();
488
489 inline bool IsMediaResetNeeded(uint32_t options)
490 {
491 return (options & CM_DEVICE_CONFIG_MEDIA_RESET_ENABLE) ? true : false;
492 }
493
494 virtual int32_t ReadVtuneProfilingFlag() = 0;
495
496 virtual void ConstructOSSpecific(uint32_t devCreateOption) = 0;
497
498 virtual int32_t QuerySurface2DFormats(void *pCapValue,
499 uint32_t & capValueSize) = 0;
500
501 virtual int32_t InitializeOSSpecific(MOS_CONTEXT *pUmdContext) = 0;
502
503 virtual CM_RETURN_CODE QueryGPUInfoInternal(PCM_QUERY_CAPS pQueryCaps) = 0;
504
505 virtual CM_RETURN_CODE QuerySurface2DFormatsInternal(PCM_QUERY_CAPS pQueryCaps) = 0;
506
507 int32_t FlushPrintBufferInternal(const char *filename);
508
509 MOS_CONTEXT *m_mosContext;
510
511 void* m_accelData; // Pointer to the private data used by the acceleration service
512
513 uint32_t m_accelSize; // Size of the private data
514
515 CM_HAL_MAX_VALUES m_halMaxValues;
516
517 CM_HAL_MAX_VALUES_EX m_halMaxValuesEx;
518
519 CmSurfaceManager* m_surfaceMgr;
520
521 std::vector<CmQueueRT *> m_queue;
522
523 CmDynamicArray m_programArray;
524
525 uint32_t m_programCount;
526
527 CmDynamicArray m_kernelArray;
528
529 uint32_t m_kernelCount;
530
531 CmDynamicArray m_sampler8x8Array;
532
533 CmDynamicArray m_samplerArray;
534
535 CmDynamicArray m_threadSpaceArray;
536
537 uint32_t m_threadSpaceCount;
538
539 CmDynamicArray m_veboxArray;
540
541 uint32_t m_veboxCount;
542
543 HMODULE m_hJITDll;
544
545 pJITCompile m_fJITCompile;
546
547 pJITCompile_v2 m_fJITCompile_v2;
548
549 pFreeBlock m_fFreeBlock;
550
551 pJITVersion m_fJITVersion;
552
553 uint32_t m_ddiVersion;
554
555 uint32_t m_platform;
556
557 uint32_t m_cmDeviceRefCount;
558
559 CmProgram* m_gpuCopyKernelProgram;
560
561 CmProgram* m_surfInitKernelProgram;
562
563 CmQueue* m_InitCmQueue;
564
565 CmKernel* m_kernel0;
566
567 CmKernel* m_kernel1;
568
569 CmTask* m_gpuInitTask0;
570
571 CmTask* m_gpuInitTask1;
572
573 #if USE_EXTENSION_CODE
574 CmGTPin *m_gtpin;
575 #endif
576
577 // synchronization objects
578 CSync m_criticalSectionProgramKernel;
579
580 CSync m_criticalSectionSurface;
581
582 CSync m_criticalSectionReadWriteSurface2D;
583
584 CSync m_criticalSectionSampler;
585
586 CSync m_criticalSectionSampler8x8;
587
588 CSync m_criticalSectionVmeState;
589
590 CSync m_criticalSectionThreadSpace;
591
592 CSync m_criticalSectionDeviceRefCount;
593
594 CSync m_criticalSectionThreadGroupSpace;
595
596 CSync m_criticalSectionTask;
597
598 CSync m_criticalSectionVebox;
599
600 CSync m_criticalSectionQueue;
601
602 std::list<uint8_t *> m_printBufferMems;
603
604 std::list<CmBufferUP *> m_printBufferUPs;
605
606 bool m_isPrintEnabled;
607
608 size_t m_printBufferSize;
609
610 CmDynamicArray m_threadGroupSpaceArray;
611
612 uint32_t m_threadGroupSpaceCount;
613
614 CmDynamicArray m_taskArray;
615
616 uint32_t m_taskCount;
617
618 CM_HAL_CREATE_PARAM m_cmHalCreateOption;
619
620 uint32_t m_nGPUFreqOriginal;
621
622 uint32_t m_nGPUFreqMin;
623
624 uint32_t m_nGPUFreqMax;
625
626 bool m_vtuneOn;
627
628 uint32_t m_isDriverStoreEnabled;
629
630 CmNotifierGroup *m_notifierGroup;
631
632 bool m_hasGpuCopyKernel;
633
634 bool m_hasGpuInitKernel;
635
636 uint32_t m_kernelsLoaded;
637
638 bool m_preloadKernelEnabled;
639
640 uint8_t m_queuePriority;
641
642 static const uint32_t m_maxPrintBuffer;
643 private:
644 CmDeviceRTBase(const CmDeviceRTBase& other);
645
646 CmDeviceRTBase& operator= (const CmDeviceRTBase& other);
647 };
648 }; //namespace
649
650 #endif // #ifndef MEDIADRIVER_COMMON_CM_CMDEVICERT_BASE_H_