1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
|
/*
* Copyright (C) 2017-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/source/helpers/basic_math.h"
#include "shared/source/os_interface/linux/engine_info.h"
#include "shared/source/os_interface/linux/hw_device_id.h"
#include "shared/source/os_interface/linux/memory_info.h"
#include "shared/source/utilities/api_intercept.h"
#include "shared/source/utilities/stackvec.h"
#include "drm/i915_drm.h"
#include "engine_node.h"
#include "igfxfmid.h"
#include <array>
#include <cerrno>
#include <fcntl.h>
#include <memory>
#include <string>
#include <sys/ioctl.h>
#include <unistd.h>
#include <vector>
struct GT_SYSTEM_INFO;
namespace NEO {
#define I915_CONTEXT_PRIVATE_PARAM_BOOST 0x80000000
class BufferObject;
class DeviceFactory;
class OsContext;
struct HardwareInfo;
struct RootDeviceEnvironment;
struct DeviceDescriptor { // NOLINT(clang-analyzer-optin.performance.Padding)
unsigned short deviceId;
const HardwareInfo *pHwInfo;
void (*setupHardwareInfo)(HardwareInfo *, bool);
GTTYPE eGtType;
};
extern const DeviceDescriptor deviceDescriptorTable[];
class Drm {
friend DeviceFactory;
public:
enum class ResourceClass : uint32_t {
Elf,
Isa,
ModuleHeapDebugArea,
ContextSaveArea,
SbaTrackingBuffer,
MaxSize
};
static const std::array<const char *, size_t(ResourceClass::MaxSize)> classNames;
virtual ~Drm();
virtual int ioctl(unsigned long request, void *arg);
int getDeviceID(int &devId);
int getDeviceRevID(int &revId);
int getExecSoftPin(int &execSoftPin);
int enableTurboBoost();
int getEuTotal(int &euTotal);
int getSubsliceTotal(int &subsliceTotal);
int getMaxGpuFrequency(HardwareInfo &hwInfo, int &maxGpuFrequency);
int getEnabledPooledEu(int &enabled);
int getMinEuInPool(int &minEUinPool);
int queryGttSize(uint64_t >tSizeOutput);
bool isPreemptionSupported() const { return preemptionSupported; }
MOCKABLE_VIRTUAL void checkPreemptionSupport();
inline int getFileDescriptor() const { return hwDeviceId->getFileDescriptor(); }
int createDrmVirtualMemory(uint32_t &drmVmId);
void destroyDrmVirtualMemory(uint32_t drmVmId);
uint32_t createDrmContext(uint32_t drmVmId);
void destroyDrmContext(uint32_t drmContextId);
int queryVmId(uint32_t drmContextId, uint32_t &vmId);
void setLowPriorityContextParam(uint32_t drmContextId);
unsigned int bindDrmContext(uint32_t drmContextId, uint32_t deviceIndex, aub_stream::EngineType engineType);
void setGtType(GTTYPE eGtType) { this->eGtType = eGtType; }
GTTYPE getGtType() const { return this->eGtType; }
MOCKABLE_VIRTUAL int getErrno();
bool setQueueSliceCount(uint64_t sliceCount);
void checkQueueSliceSupport();
uint64_t getSliceMask(uint64_t sliceCount);
MOCKABLE_VIRTUAL bool queryEngineInfo();
MOCKABLE_VIRTUAL bool queryMemoryInfo();
bool queryTopology(int &sliceCount, int &subSliceCount, int &euCount);
bool createVirtualMemoryAddressSpace(uint32_t vmCount);
void destroyVirtualMemoryAddressSpace();
uint32_t getVirtualMemoryAddressSpace(uint32_t vmId);
int bindBufferObject(OsContext *osContext, uint32_t vmHandleId, BufferObject *bo);
int unbindBufferObject(OsContext *osContext, uint32_t vmHandleId, BufferObject *bo);
int setupHardwareInfo(DeviceDescriptor *, bool);
bool areNonPersistentContextsSupported() const { return nonPersistentContextsSupported; }
void checkNonPersistentContextsSupport();
void setNonPersistentContext(uint32_t drmContextId);
bool isPerContextVMRequired() {
return requirePerContextVM;
}
MOCKABLE_VIRTUAL bool registerResourceClasses();
MOCKABLE_VIRTUAL uint32_t registerResource(ResourceClass classType, void *data, size_t size);
MOCKABLE_VIRTUAL void unregisterResource(uint32_t handle);
MemoryInfo *getMemoryInfo() const {
return memoryInfo.get();
}
EngineInfo *getEngineInfo() const {
return engineInfo.get();
}
RootDeviceEnvironment &getRootDeviceEnvironment() {
return rootDeviceEnvironment;
}
bool resourceRegistrationEnabled() {
return classHandles.size() > 0;
}
static inline uint32_t createMemoryRegionId(uint16_t type, uint16_t instance) {
return (1u << (type + 16)) | (1u << instance);
}
static inline uint16_t getMemoryTypeFromRegion(uint32_t region) { return Math::log2(region >> 16); };
static inline uint16_t getMemoryInstanceFromRegion(uint32_t region) { return Math::log2(region & 0xFFFF); };
static bool isi915Version(int fd);
static Drm *create(std::unique_ptr<HwDeviceId> hwDeviceId, RootDeviceEnvironment &rootDeviceEnvironment);
static void overrideBindSupport(bool &useVmBind);
bool isBindAvailable() {
return this->bindAvailable;
}
void setBindAvailable() {
this->bindAvailable = true;
}
protected:
int getQueueSliceCount(drm_i915_gem_context_param_sseu *sseu);
std::string generateUUID();
bool sliceCountChangeSupported = false;
drm_i915_gem_context_param_sseu sseu{};
bool preemptionSupported = false;
bool nonPersistentContextsSupported = false;
bool requirePerContextVM = false;
bool bindAvailable = false;
std::unique_ptr<HwDeviceId> hwDeviceId;
int deviceId = 0;
int revisionId = 0;
GTTYPE eGtType = GTTYPE_UNDEFINED;
RootDeviceEnvironment &rootDeviceEnvironment;
uint64_t uuid = 0;
Drm(std::unique_ptr<HwDeviceId> hwDeviceIdIn, RootDeviceEnvironment &rootDeviceEnvironment);
std::unique_ptr<EngineInfo> engineInfo;
std::unique_ptr<MemoryInfo> memoryInfo;
std::vector<uint32_t> virtualMemoryIds;
std::string getSysFsPciPath();
std::unique_ptr<uint8_t[]> query(uint32_t queryId, int32_t &length);
StackVec<uint32_t, size_t(ResourceClass::MaxSize)> classHandles;
#pragma pack(1)
struct PCIConfig {
uint16_t VendorID;
uint16_t DeviceID;
uint16_t Command;
uint16_t Status;
uint8_t Revision;
uint8_t ProgIF;
uint8_t Subclass;
uint8_t ClassCode;
uint8_t cacheLineSize;
uint8_t LatencyTimer;
uint8_t HeaderType;
uint8_t BIST;
uint32_t BAR0[6];
uint32_t CardbusCISPointer;
uint16_t SubsystemVendorID;
uint16_t SubsystemDeviceID;
uint32_t ROM;
uint8_t Capabilities;
uint8_t Reserved[7];
uint8_t InterruptLine;
uint8_t InterruptPIN;
uint8_t MinGrant;
uint8_t MaxLatency;
};
#pragma pack()
private:
int getParamIoctl(int param, int *dstValue);
};
} // namespace NEO
|
