blob: 337c5facec8ece1e4e77aa0579d88a2d89612d4d (
plain)
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
|
#pragma once
#include <condition_variable>
#include <mutex>
#include <queue>
#include "../util/thread.h"
#include "../vulkan/vulkan_presenter.h"
#include "dxvk_cmdlist.h"
namespace dxvk {
class DxvkDevice;
/**
* \brief Submission status
*
* Stores the result of a queue
* submission or a present call.
*/
struct DxvkSubmitStatus {
std::atomic<VkResult> result = { VK_SUCCESS };
};
/**
* \brief Queue submission info
*
* Stores parameters used to submit
* a command buffer to the device.
*/
struct DxvkSubmitInfo {
Rc<DxvkCommandList> cmdList;
VkSemaphore waitSync;
VkSemaphore wakeSync;
};
/**
* \brief Present info
*
* Stores parameters used to present
* a swap chain image on the device.
*/
struct DxvkPresentInfo {
Rc<vk::Presenter> presenter;
};
/**
* \brief Submission queue entry
*/
struct DxvkSubmitEntry {
DxvkSubmitStatus* status;
DxvkSubmitInfo submit;
DxvkPresentInfo present;
};
/**
* \brief Submission queue
*/
class DxvkSubmissionQueue {
public:
DxvkSubmissionQueue(DxvkDevice* device);
~DxvkSubmissionQueue();
/**
* \brief Number of pending submissions
*
* A return value of 0 indicates
* that the GPU is currently idle.
* \returns Pending submission count
*/
uint32_t pendingSubmissions() const {
return m_pending.load();
}
/**
* \brief Retrieves estimated GPU idle time
*
* This is a monotonically increasing counter
* which can be evaluated periodically in order
* to calculate the GPU load.
* \returns Accumulated GPU idle time, in us
*/
uint64_t gpuIdleTicks() const {
return m_gpuIdle.load();
}
/**
* \brief Retrieves last submission error
*
* In case an error occured during asynchronous command
* submission, it will be returned by this function.
* \returns Last error from command submission
*/
VkResult getLastError() const {
return m_lastError.load();
}
/**
* \brief Submits a command list asynchronously
*
* Queues a command list for submission on the
* dedicated submission thread. Use this to take
* the submission overhead off the calling thread.
* \param [in] submitInfo Submission parameters
*/
void submit(
DxvkSubmitInfo submitInfo);
/**
* \brief Presents an image synchronously
*
* Waits for queued command lists to be submitted
* and then presents the current swap chain image
* of the presenter. May stall the calling thread.
* \param [in] present Present parameters
* \returns Status of the operation
*/
void present(
DxvkPresentInfo presentInfo,
DxvkSubmitStatus* status);
/**
* \brief Synchronizes with one queue submission
*
* Waits for the result of the given submission
* or present operation to become available.
* \param [in,out] status Submission status
*/
void synchronizeSubmission(
DxvkSubmitStatus* status);
/**
* \brief Synchronizes with queue submissions
*
* Waits for all pending command lists to be
* submitted to the GPU before returning.
*/
void synchronize();
/**
* \brief Locks device queue
*
* Locks the mutex that protects the Vulkan queue
* that DXVK uses for command buffer submission.
* This is needed when the app submits its own
* command buffers to the queue.
*/
void lockDeviceQueue();
/**
* \brief Unlocks device queue
*
* Unlocks the mutex that protects the Vulkan
* queue used for command buffer submission.
*/
void unlockDeviceQueue();
private:
DxvkDevice* m_device;
std::atomic<VkResult> m_lastError = { VK_SUCCESS };
std::atomic<bool> m_stopped = { false };
std::atomic<uint32_t> m_pending = { 0u };
std::atomic<uint64_t> m_gpuIdle = { 0ull };
dxvk::mutex m_mutex;
dxvk::mutex m_mutexQueue;
dxvk::condition_variable m_appendCond;
dxvk::condition_variable m_submitCond;
dxvk::condition_variable m_finishCond;
std::queue<DxvkSubmitEntry> m_submitQueue;
std::queue<DxvkSubmitEntry> m_finishQueue;
dxvk::thread m_submitThread;
dxvk::thread m_finishThread;
VkResult submitToQueue(
const DxvkSubmitInfo& submission);
void submitCmdLists();
void finishCmdLists();
};
}
|
