1 /*
2 * Copyright (c) 2018, 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      cm_execution_adv.h
24 //! \brief     Contains Class CmExecutionAdv  definitions
25 //!
26 #pragma once
27 
28 #include "cm_hal.h"
29 #include "cm_csync.h"
30 
31 class CmTracker;
32 class CmISH;
33 class CmDSH;
34 class CmSurfaceStateBufferMgr;
35 class CmSurfaceState2Dor3DMgr;
36 class CmSurfaceStateVME;
37 namespace CMRT_UMD
38 {
39 class CmDeviceRT;
40 class CmKernelRT;
41 class CmProgramRT;
42 class CmQueueRT;
43 class CmTask;
44 class CmThreadSpace;
45 class CmThreadGroupSpace;
46 class CmEvent;
47 };
48 
49 class CmExecutionAdv
50 {
51 public:
52     CmExecutionAdv();
53     virtual ~CmExecutionAdv();
54     virtual MOS_STATUS Initialize(CM_HAL_STATE *state);
GetTracker()55     virtual CmTracker *GetTracker() {return m_tracker; }
GetISH()56     virtual CmISH *GetISH() {return m_ish; }
GetDSH()57     virtual CmDSH *GetDSH() {return m_dsh; }
58     virtual CmSurfaceState2Dor3DMgr *Create2DStateMgr(MOS_RESOURCE *resource);
59     virtual CmSurfaceState2Dor3DMgr *Create3DStateMgr(MOS_RESOURCE *resource);
60     virtual void Delete2Dor3DStateMgr(CmSurfaceState2Dor3DMgr *stateMgr);
61     virtual CmSurfaceStateBufferMgr *CreateBufferStateMgr(MOS_RESOURCE *resource);
62     virtual void DeleteBufferStateMgr(CmSurfaceStateBufferMgr *stateMgr);
63     virtual void DeleteSurfStateVme(CmSurfaceStateVME *state);
64     virtual void SetBufferOrigSize(CmSurfaceStateBufferMgr *stateMgr, uint32_t size);
65     virtual void SetBufferMemoryObjectControl(CmSurfaceStateBufferMgr *stateMgr, uint16_t mocs);
66     virtual void Set2Dor3DOrigFormat(CmSurfaceState2Dor3DMgr *stateMgr, MOS_FORMAT format);
67     virtual void Set2Dor3DOrigDimension(CmSurfaceState2Dor3DMgr *stateMgr, uint32_t width, uint32_t height, uint32_t depth);
68     virtual void Set2DRenderTarget(CmSurfaceState2Dor3DMgr *stateMgr, bool renderTarget);
69     virtual void Set2Dor3DMemoryObjectControl(CmSurfaceState2Dor3DMgr *stateMgr, uint16_t mocs);
70     virtual void Set2DFrameType(CmSurfaceState2Dor3DMgr *stateMgr, CM_FRAME_TYPE frameType);
71     virtual void SetRotationFlag(CmSurfaceState2Dor3DMgr *stateMgr, uint32_t rotation);
72     virtual void SetChromaSitting(CmSurfaceState2Dor3DMgr *stateMgr, uint8_t chromaSitting);
73     virtual FrameTrackerProducer *GetFastTrackerProducer();
74     virtual CMRT_UMD::CmKernelRT *CreateKernelRT(CMRT_UMD::CmDeviceRT *device,
75                CMRT_UMD::CmProgramRT *program,
76                uint32_t kernelIndex,
77                uint32_t kernelSeqNum);
78     virtual int SubmitTask(CMRT_UMD::CmQueueRT *queue,
79                 CMRT_UMD::CmTask *task,
80                 CMRT_UMD::CmEvent *&event,
81                 const CMRT_UMD::CmThreadSpace *threadSpace,
82                 MOS_GPU_CONTEXT gpuContext);
83     virtual int DestoryEvent(CMRT_UMD::CmQueueRT *queue, CMRT_UMD::CmEvent *&event);
84     virtual int SubmitComputeTask(CMRT_UMD::CmQueueRT *queue,
85                 CMRT_UMD::CmTask *task,
86                 CMRT_UMD::CmEvent* &event,
87                 const CMRT_UMD::CmThreadGroupSpace* threadGroupSpace,
88                 MOS_GPU_CONTEXT gpuContext);
89     virtual int WaitForAllTasksFinished();
90 
91     virtual void SetL3Config(const L3ConfigRegisterValues *l3Config);
92 
93     virtual int SetSuggestedL3Config(L3_SUGGEST_CONFIG l3SuggestConfig);
94 
95     virtual int AssignNewTracker();
96 
97     virtual int SubmitGpgpuTask(CMRT_UMD::CmQueueRT *queue,
98                 CMRT_UMD::CmTask *task,
99                 CMRT_UMD::CmEvent* &event,
100                 const CMRT_UMD::CmThreadGroupSpace* threadGroupSpace,
101                 MOS_GPU_CONTEXT gpuContext);
102 
103     virtual bool SwitchToFastPath(CMRT_UMD::CmTask *task);
104 
105 protected:
106     int RefreshSurfaces(CMRT_UMD::CmDeviceRT *device);
107 
108     CM_HAL_STATE *m_cmhal;
109     CmTracker *m_tracker;
110     CmISH *m_ish;
111     CmDSH *m_dsh;
112     CMRT_UMD::CSync m_criticalSection;
113     L3ConfigRegisterValues m_l3Values;
114 
115 };
116 
117