fabi/Xenia-Canary
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Track batch fences with the batches.

Browse Source
This commit is contained in:
Dr. Chat
2016-11-08 18:11:12 -06:00
parent 391b6e9bb7
commit 48f6ba747c
11 changed files with 255 additions and 108 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/xenia/ui/vulkan/circular_buffer.cc
View File

@@ -164,8 +164,8 @@ bool CircularBuffer::CanAcquire(VkDeviceSize length) {
return false;
}
CircularBuffer::Allocation* CircularBuffer::Acquire(
VkDeviceSize length, std::shared_ptr<Fence> fence) {
CircularBuffer::Allocation* CircularBuffer::Acquire(VkDeviceSize length,
VkFence fence) {
VkDeviceSize aligned_length = xe::round_up(length, alignment_);
if (!CanAcquire(aligned_length)) {
return nullptr;
@@ -243,7 +243,7 @@ void CircularBuffer::Clear() {
void CircularBuffer::Scavenge() {
for (auto it = allocations_.begin(); it != allocations_.end();) {
if ((*it)->fence->status() != VK_SUCCESS) {
if (vkGetFenceStatus(*device_, (*it)->fence) != VK_SUCCESS) {
// Don't bother freeing following allocations to ensure proper ordering.
break;
}

4
src/xenia/ui/vulkan/circular_buffer.h
View File

@@ -40,7 +40,7 @@ class CircularBuffer {
// Allocation usage fence. This allocation will be deleted when the fence
// becomes signaled.
std::shared_ptr<Fence> fence;
VkFence fence;
};
bool Initialize(VkDeviceMemory memory, VkDeviceSize offset);
@@ -59,7 +59,7 @@ class CircularBuffer {
// Acquires space to hold memory. This allocation is only freed when the fence
// reaches the signaled state.
Allocation* Acquire(VkDeviceSize length, std::shared_ptr<Fence> fence);
Allocation* Acquire(VkDeviceSize length, VkFence fence);
void Flush(Allocation* allocation);
// Clears all allocations, regardless of whether they've been consumed or not.

40
src/xenia/ui/vulkan/fenced_pools.cc
View File

@@ -48,7 +48,7 @@ CommandBufferPool::CommandBufferPool(VkDevice device,
vkAllocateCommandBuffers(device_, &command_buffer_info, command_buffers);
CheckResult(err, "vkCreateCommandBuffer");
for (size_t i = 0; i < xe::countof(command_buffers); ++i) {
PushEntry(command_buffers[i]);
PushEntry(command_buffers[i], nullptr);
}
}
@@ -58,7 +58,7 @@ CommandBufferPool::~CommandBufferPool() {
command_pool_ = nullptr;
}
VkCommandBuffer CommandBufferPool::AllocateEntry() {
VkCommandBuffer CommandBufferPool::AllocateEntry(void* data) {
// TODO(benvanik): allocate a bunch at once?
VkCommandBufferAllocateInfo command_buffer_info;
command_buffer_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
@@ -77,6 +77,42 @@ void CommandBufferPool::FreeEntry(VkCommandBuffer handle) {
vkFreeCommandBuffers(device_, command_pool_, 1, &handle);
}
DescriptorPool::DescriptorPool(VkDevice device, uint32_t max_count,
std::vector<VkDescriptorPoolSize> pool_sizes)
: BaseFencedPool(device) {
VkDescriptorPoolCreateInfo descriptor_pool_info;
descriptor_pool_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
descriptor_pool_info.pNext = nullptr;
descriptor_pool_info.flags =
VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT;
descriptor_pool_info.maxSets = max_count;
descriptor_pool_info.poolSizeCount = uint32_t(pool_sizes.size());
descriptor_pool_info.pPoolSizes = pool_sizes.data();
auto err = vkCreateDescriptorPool(device, &descriptor_pool_info, nullptr,
&descriptor_pool_);
CheckResult(err, "vkCreateDescriptorPool");
}
DescriptorPool::~DescriptorPool() {}
VkDescriptorSet DescriptorPool::AllocateEntry(void* data) {
VkDescriptorSetLayout layout = reinterpret_cast<VkDescriptorSetLayout>(data);
VkDescriptorSet descriptor_set = nullptr;
VkDescriptorSetAllocateInfo set_alloc_info;
set_alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
set_alloc_info.pNext = nullptr;
set_alloc_info.descriptorPool = descriptor_pool_;
set_alloc_info.descriptorSetCount = 1;
set_alloc_info.pSetLayouts = &layout;
auto err =
vkAllocateDescriptorSets(device_, &set_alloc_info, &descriptor_set);
CheckResult(err, "vkAllocateDescriptorSets");
return descriptor_set;
}
void DescriptorPool::FreeEntry(VkDescriptorSet handle) {}
} // namespace vulkan
} // namespace ui
} // namespace xe

119
src/xenia/ui/vulkan/fenced_pools.h
View File

@@ -49,7 +49,7 @@ class BaseFencedPool {
void Scavenge() {
while (pending_batch_list_head_) {
auto batch = pending_batch_list_head_;
if (vkGetFenceStatus(device_, *batch->fence) == VK_SUCCESS) {
if (vkGetFenceStatus(device_, batch->fence) == VK_SUCCESS) {
// Batch has completed. Reclaim.
pending_batch_list_head_ = batch->next;
if (batch == pending_batch_list_tail_) {
@@ -72,7 +72,7 @@ class BaseFencedPool {
// Begins a new batch.
// All entries acquired within this batch will be marked as in-use until
// the fence specified in EndBatch is signalled.
void BeginBatch() {
VkFence BeginBatch() {
assert_null(open_batch_);
Batch* batch = nullptr;
if (free_batch_list_head_) {
@@ -80,15 +80,26 @@ class BaseFencedPool {
batch = free_batch_list_head_;
free_batch_list_head_ = batch->next;
batch->next = nullptr;
vkResetFences(device_, 1, &batch->fence);
} else {
// Allocate new batch.
batch = new Batch();
batch->next = nullptr;
VkFenceCreateInfo info;
info.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
info.pNext = nullptr;
info.flags = 0;
VkResult res = vkCreateFence(device_, &info, nullptr, &batch->fence);
if (res != VK_SUCCESS) {
assert_always();
}
}
batch->entry_list_head = nullptr;
batch->entry_list_tail = nullptr;
batch->fence = nullptr;
open_batch_ = batch;
return batch->fence;
}
// Cancels an open batch, and releases all entries acquired within.
@@ -109,33 +120,8 @@ class BaseFencedPool {
batch->entry_list_tail = nullptr;
}
// Attempts to acquire an entry from the pool in the current batch.
// If none are available a new one will be allocated.
HANDLE AcquireEntry() {
Entry* entry = nullptr;
if (free_entry_list_head_) {
// Slice off an entry from the free list.
entry = free_entry_list_head_;
free_entry_list_head_ = entry->next;
} else {
// No entry available; allocate new.
entry = new Entry();
entry->handle = static_cast<T*>(this)->AllocateEntry();
}
entry->next = nullptr;
if (!open_batch_->entry_list_head) {
open_batch_->entry_list_head = entry;
}
if (open_batch_->entry_list_tail) {
open_batch_->entry_list_tail->next = entry;
}
open_batch_->entry_list_tail = entry;
return entry->handle;
}
// Ends the current batch using the given fence to indicate when the batch
// has completed execution on the GPU.
void EndBatch(std::shared_ptr<Fence> fence) {
// Ends the current batch.
void EndBatch() {
assert_not_null(open_batch_);
// Close and see if we have anything.
@@ -148,9 +134,6 @@ class BaseFencedPool {
return;
}
// Track the fence.
batch->fence = fence;
// Append to the end of the batch list.
batch->next = nullptr;
if (!pending_batch_list_head_) {
@@ -165,9 +148,52 @@ class BaseFencedPool {
}
protected:
void PushEntry(HANDLE handle) {
// Attempts to acquire an entry from the pool in the current batch.
// If none are available a new one will be allocated.
HANDLE AcquireEntry(void* data) {
Entry* entry = nullptr;
if (free_entry_list_head_) {
// Slice off an entry from the free list.
Entry* prev = nullptr;
Entry* cur = free_entry_list_head_;
while (cur != nullptr) {
if (cur->data == data) {
if (prev) {
prev->next = cur->next;
} else {
free_entry_list_head_ = cur->next;
}
entry = cur;
break;
}
prev = cur;
cur = cur->next;
}
}
if (!entry) {
// No entry available; allocate new.
entry = new Entry();
entry->data = data;
entry->handle = static_cast<T*>(this)->AllocateEntry(data);
}
entry->next = nullptr;
if (!open_batch_->entry_list_head) {
open_batch_->entry_list_head = entry;
}
if (open_batch_->entry_list_tail) {
open_batch_->entry_list_tail->next = entry;
}
open_batch_->entry_list_tail = entry;
return entry->handle;
}
void PushEntry(HANDLE handle, void* data) {
auto entry = new Entry();
entry->next = free_entry_list_head_;
entry->data = data;
entry->handle = handle;
free_entry_list_head_ = entry;
}
@@ -192,13 +218,14 @@ class BaseFencedPool {
private:
struct Entry {
Entry* next;
void* data;
HANDLE handle;
};
struct Batch {
Batch* next;
Entry* entry_list_head;
Entry* entry_list_tail;
std::shared_ptr<Fence> fence;
VkFence fence;
};
Batch* free_batch_list_head_ = nullptr;
@@ -211,19 +238,39 @@ class BaseFencedPool {
class CommandBufferPool
: public BaseFencedPool<CommandBufferPool, VkCommandBuffer> {
public:
typedef BaseFencedPool<CommandBufferPool, VkCommandBuffer> Base;
CommandBufferPool(VkDevice device, uint32_t queue_family_index,
VkCommandBufferLevel level);
~CommandBufferPool() override;
VkCommandBuffer AcquireEntry() { return Base::AcquireEntry(nullptr); }
protected:
friend class BaseFencedPool<CommandBufferPool, VkCommandBuffer>;
VkCommandBuffer AllocateEntry();
VkCommandBuffer AllocateEntry(void* data);
void FreeEntry(VkCommandBuffer handle);
VkCommandPool command_pool_ = nullptr;
VkCommandBufferLevel level_ = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
};
class DescriptorPool : public BaseFencedPool<DescriptorPool, VkDescriptorSet> {
public:
DescriptorPool(VkDevice device, uint32_t max_count,
std::vector<VkDescriptorPoolSize> pool_sizes);
~DescriptorPool() override;
VkDescriptorSet AcquireEntry(VkDescriptorSetLayout layout) { return nullptr; }
protected:
friend class BaseFencedPool<DescriptorPool, VkCommandBuffer>;
VkDescriptorSet AllocateEntry(void* data);
void FreeEntry(VkDescriptorSet handle);
VkDescriptorPool descriptor_pool_ = nullptr;
};
} // namespace vulkan
} // namespace ui
} // namespace xe

48
src/xenia/ui/vulkan/vulkan_device.cc
View File

@@ -55,6 +55,9 @@ VulkanDevice::VulkanDevice(VulkanInstance* instance) : instance_(instance) {
DeclareRequiredLayer("VK_LAYER_LUNARG_image", Version::Make(0, 0, 0), true);
*/
}
DeclareRequiredExtension(VK_EXT_DEBUG_MARKER_EXTENSION_NAME,
Version::Make(0, 0, 0), true);
}
VulkanDevice::~VulkanDevice() {
@@ -221,6 +224,51 @@ void VulkanDevice::ReleaseQueue(VkQueue queue) {
free_queues_.push_back(queue);
}
void VulkanDevice::DbgSetObjectName(VkDevice device, uint64_t object,
VkDebugReportObjectTypeEXT object_type,
std::string name) {
PFN_vkDebugMarkerSetObjectNameEXT pfn_vkDebugMarkerSetObjectNameEXT = nullptr;
if (!pfn_vkDebugMarkerSetObjectNameEXT) {
pfn_vkDebugMarkerSetObjectNameEXT =
(PFN_vkDebugMarkerSetObjectNameEXT)vkGetDeviceProcAddr(
device, "vkDebugMarkerSetObjectNameEXT");
if (!pfn_vkDebugMarkerSetObjectNameEXT) {
return;
}
}
VkDebugMarkerObjectNameInfoEXT info;
info.sType = VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT;
info.pNext = nullptr;
info.objectType = object_type;
info.object = object;
info.pObjectName = name.c_str();
pfn_vkDebugMarkerSetObjectNameEXT(device, &info);
}
void VulkanDevice::DbgSetObjectName(uint64_t object,
VkDebugReportObjectTypeEXT object_type,
std::string name) {
if (!pfn_vkDebugMarkerSetObjectNameEXT_) {
pfn_vkDebugMarkerSetObjectNameEXT_ =
(PFN_vkDebugMarkerSetObjectNameEXT)vkGetDeviceProcAddr(
handle, "vkDebugMarkerSetObjectNameEXT");
if (!pfn_vkDebugMarkerSetObjectNameEXT_) {
return;
}
}
VkDebugMarkerObjectNameInfoEXT info;
info.sType = VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT;
info.pNext = nullptr;
info.objectType = object_type;
info.object = object;
info.pObjectName = name.c_str();
pfn_vkDebugMarkerSetObjectNameEXT_(handle, &info);
}
bool VulkanDevice::is_renderdoc_attached() const {
return instance_->is_renderdoc_attached();
}

8
src/xenia/ui/vulkan/vulkan_device.h
View File

@@ -75,6 +75,12 @@ class VulkanDevice {
// This method is thread safe.
void ReleaseQueue(VkQueue queue);
static void DbgSetObjectName(VkDevice device, uint64_t object,
VkDebugReportObjectTypeEXT object_type,
std::string name);
void DbgSetObjectName(uint64_t object, VkDebugReportObjectTypeEXT object_type,
std::string name);
// True if RenderDoc is attached and available for use.
bool is_renderdoc_attached() const;
// Begins capturing the current frame in RenderDoc, if it is attached.
@@ -95,6 +101,8 @@ class VulkanDevice {
std::vector<Requirement> required_layers_;
std::vector<Requirement> required_extensions_;
PFN_vkDebugMarkerSetObjectNameEXT pfn_vkDebugMarkerSetObjectNameEXT_;
DeviceInfo device_info_;
uint32_t queue_family_index_ = 0;
std::mutex queue_mutex_;

3
src/xenia/ui/vulkan/vulkan_instance.cc
View File

@@ -58,6 +58,9 @@ VulkanInstance::VulkanInstance() {
DeclareRequiredExtension(VK_EXT_DEBUG_REPORT_EXTENSION_NAME,
Version::Make(0, 0, 0), true);
}
DeclareRequiredExtension(VK_EXT_DEBUG_MARKER_EXTENSION_NAME,
Version::Make(0, 0, 0), true);
}
VulkanInstance::~VulkanInstance() { DestroyInstance(); }