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
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
|
#pragma once
#include "dxvk_device_info.h"
#include "dxvk_extensions.h"
#include "dxvk_include.h"
namespace dxvk {
class DxvkDevice;
class DxvkInstance;
/**
* \brief GPU vendors
* Based on PCIe IDs.
*/
enum class DxvkGpuVendor : uint16_t {
Amd = 0x1002,
Nvidia = 0x10de,
Intel = 0x8086,
};
/**
* \brief Adapter memory heap info
*
* Stores info about a heap, and the amount
* of memory allocated from it by the app.
*/
struct DxvkAdapterMemoryHeapInfo {
VkMemoryHeapFlags heapFlags;
VkDeviceSize memoryBudget;
VkDeviceSize memoryAllocated;
};
/**
* \brief Adapter memory info
*
* Stores properties and allocation
* info of each available heap.
*/
struct DxvkAdapterMemoryInfo {
uint32_t heapCount;
DxvkAdapterMemoryHeapInfo heaps[VK_MAX_MEMORY_HEAPS];
};
/**
* \brief Retrieves queue indices
*/
struct DxvkAdapterQueueIndices {
uint32_t graphics;
uint32_t transfer;
};
/**
* \brief DXVK adapter
*
* Corresponds to a physical device in Vulkan. Provides
* all kinds of information about the device itself and
* the supported feature set.
*/
class DxvkAdapter : public RcObject {
public:
DxvkAdapter(
const Rc<vk::InstanceFn>& vki,
VkPhysicalDevice handle);
~DxvkAdapter();
/**
* \brief Vulkan instance functions
* \returns Vulkan instance functions
*/
Rc<vk::InstanceFn> vki() const {
return m_vki;
}
/**
* \brief Physical device handle
* \returns The adapter handle
*/
VkPhysicalDevice handle() const {
return m_handle;
}
/**
* \brief Physical device properties
*
* Returns a read-only reference to the core
* properties of the Vulkan physical device.
* \returns Physical device core properties
*/
const VkPhysicalDeviceProperties& deviceProperties() const {
return m_deviceInfo.core.properties;
}
/**
* \brief Device info
*
* Returns a read-only reference to the full
* device info structure, including extended
* properties.
* \returns Device info struct
*/
const DxvkDeviceInfo& devicePropertiesExt() const {
return m_deviceInfo;
}
/**
* \brief Supportred device features
*
* Queries the supported device features.
* \returns Device features
*/
const DxvkDeviceFeatures& features() const {
return m_deviceFeatures;
}
/**
* \brief Retrieves memory heap info
*
* Returns properties of all available memory heaps,
* both device-local and non-local heaps, and the
* amount of memory allocated from those heaps by
* logical devices.
* \returns Memory heap info
*/
DxvkAdapterMemoryInfo getMemoryHeapInfo() const;
/**
* \brief Memory properties
*
* Queries the memory types and memory heaps of
* the device. This is useful for memory allocators.
* \returns Device memory properties
*/
VkPhysicalDeviceMemoryProperties memoryProperties() const;
/**
* \brief Queries format support
*
* \param [in] format The format to query
* \returns Format support info
*/
VkFormatProperties formatProperties(
VkFormat format) const;
/**
* \brief Queries image format support
*
* \param [in] format Format to query
* \param [in] type Image type
* \param [in] tiling Image tiling
* \param [in] usage Image usage flags
* \param [in] flags Image create flags
* \param [out] properties Format properties
* \returns \c VK_SUCCESS or \c VK_ERROR_FORMAT_NOT_SUPPORTED
*/
VkResult imageFormatProperties(
VkFormat format,
VkImageType type,
VkImageTiling tiling,
VkImageUsageFlags usage,
VkImageCreateFlags flags,
VkImageFormatProperties& properties) const;
/**
* \brief Retrieves queue family indices
* \returns Indices for all queue families
*/
DxvkAdapterQueueIndices findQueueFamilies() const;
/**
* \brief Tests whether all required features are supported
*
* \param [in] features Required device features
* \returns \c true if all features are supported
*/
bool checkFeatureSupport(
const DxvkDeviceFeatures& required) const;
/**
* \brief Enables extensions for this adapter
*
* When creating a device, all extensions that
* are added using this method will be enabled
* in addition to the ones required by DXVK.
* This is used for OpenVR support.
*/
void enableExtensions(
const DxvkNameSet& extensions);
/**
* \brief Creates a DXVK device
*
* Creates a logical device for this adapter.
* \param [in] instance Parent instance
* \param [in] enabledFeatures Device features
* \returns Device handle
*/
Rc<DxvkDevice> createDevice(
const Rc<DxvkInstance>& instance,
DxvkDeviceFeatures enabledFeatures);
/**
* \brief Registers memory allocation
*
* Updates memory alloc info accordingly.
* \param [in] heap Memory heap index
* \param [in] bytes Allocation size
*/
void notifyHeapMemoryAlloc(
uint32_t heap,
VkDeviceSize bytes);
/**
* \brief Registers memory deallocation
*
* Updates memory alloc info accordingly.
* \param [in] heap Memory heap index
* \param [in] bytes Allocation size
*/
void notifyHeapMemoryFree(
uint32_t heap,
VkDeviceSize bytes);
/**
* \brief Tests if the driver matches certain criteria
*
* \param [in] vendor GPU vendor
* \param [in] driver Driver. Ignored when the
* driver properties extension is not supported.
* \param [in] minVer Match versions starting with this one
* \param [in] maxVer Match versions lower than this one
* \returns \c True if the driver matches these criteria
*/
bool matchesDriver(
DxvkGpuVendor vendor,
VkDriverIdKHR driver,
uint32_t minVer,
uint32_t maxVer) const;
/**
* \brief Logs DXVK adapter info
*
* May be useful for bug reports
* and general troubleshooting.
*/
void logAdapterInfo() const;
/**
* \brief Checks whether this is a UMA system
*
* Basically tests whether all heaps are device-local.
* Can be used for various optimizations in client APIs.
* \returns \c true if the system has unified memory.
*/
bool isUnifiedMemoryArchitecture() const;
private:
Rc<vk::InstanceFn> m_vki;
VkPhysicalDevice m_handle;
DxvkNameSet m_extraExtensions;
DxvkNameSet m_deviceExtensions;
DxvkDeviceInfo m_deviceInfo;
DxvkDeviceFeatures m_deviceFeatures;
bool m_hasMemoryBudget;
std::vector<VkQueueFamilyProperties> m_queueFamilies;
std::array<std::atomic<VkDeviceSize>, VK_MAX_MEMORY_HEAPS> m_heapAlloc;
void initHeapAllocInfo();
void queryExtensions();
void queryDeviceInfo();
void queryDeviceFeatures();
void queryDeviceQueues();
uint32_t findQueueFamily(
VkQueueFlags mask,
VkQueueFlags flags) const;
static void logNameList(const DxvkNameList& names);
static void logFeatures(const DxvkDeviceFeatures& features);
static void logQueueFamilies(const DxvkAdapterQueueIndices& queues);
};
}
|
