MayaFlux 1.0.0
Digital-First Multimedia Processing Framework
Loading...
Searching...
No Matches
SlotMachine.cpp
Go to the documentation of this file.
1#include "SlotMachine.hpp"
2
7
9
10namespace {
11
12 constexpr size_t k_slot_alignment = 256;
13
14 Registry::Service::BufferService* buffer_service()
15 {
17 .get_service<Registry::Service::BufferService>();
18 }
19
20 std::shared_ptr<Buffers::VKBuffer> make_buffer(size_t bytes, BufferUsageHint usage)
21 {
22 auto* service = buffer_service();
23 if (!service) {
24 return nullptr;
25 }
26
27 auto buffer = std::make_shared<Buffers::VKBuffer>(
29 service->initialize_buffer(buffer);
30 return buffer;
31 }
32
33}
34
35bool SlotArena::initialize(size_t slot_bytes, BufferUsageHint usage, size_t slots)
36{
37 release();
38
39 if (!buffer_service() || slot_bytes == 0 || slots == 0) {
41 "SlotArena needs a buffer service, a slot size and at least one slot");
42 return false;
43 }
44
46 m_stride = (slot_bytes + k_slot_alignment - 1) / k_slot_alignment * k_slot_alignment;
47 m_usage = usage;
48
49 m_uses.clear();
50 m_uses.reserve(slots);
51 for (size_t i = 0; i < slots; ++i) {
52 m_uses.push_back(std::make_shared<std::atomic<uint32_t>>(0));
53 }
54
55 m_buffer = make_buffer(m_stride * slots, usage);
56
57 if (!m_buffer || !m_buffer->is_initialized() || !m_buffer->get_mapped_ptr()) {
59 "SlotArena buffer is not host visible");
60 release();
61 return false;
62 }
63
64 return true;
65}
66
68{
69 for (size_t slot = 0; slot < m_uses.size(); ++slot) {
70 if (m_uses[slot]->load(std::memory_order_acquire) == 0) {
71 return slot;
72 }
73 }
74
75 const size_t slot = m_uses.size();
76 return grow() ? slot : 0;
77}
78
79void SlotArena::write(size_t slot, const void* data, size_t size)
80{
81 auto* service = buffer_service();
82 if (!m_buffer || !service || !data || slot >= m_uses.size() || size > m_slot_bytes) {
84 "SlotArena write rejected: slot {} of {}, {} bytes", slot, m_uses.size(), size);
85 return;
86 }
87
88 const size_t offset = slot * m_stride;
89 std::memcpy(static_cast<uint8_t*>(m_buffer->get_mapped_ptr()) + offset, data, size);
90 service->flush_range(m_buffer->get_buffer_resources().memory, offset, size);
91}
92
93SlotLease SlotArena::lease(size_t slot) const
94{
95 return slot < m_uses.size() ? SlotLease(m_uses[slot]) : SlotLease {};
96}
97
98vk::DescriptorBufferInfo SlotArena::info(size_t slot) const
99{
100 return vk::DescriptorBufferInfo { m_buffer->get_buffer_resources().buffer, slot * m_stride, m_slot_bytes };
101}
102
103std::shared_ptr<Buffers::VKBuffer> SlotArena::detach()
104{
105 m_uses.clear();
106 return std::exchange(m_buffer, nullptr);
107}
108
110{
111 auto* service = buffer_service();
112 if (m_buffer && m_buffer->is_initialized() && service && service->retire_buffer) {
113 service->retire_buffer(m_buffer);
114 }
115 m_buffer.reset();
116 m_uses.clear();
117}
118
120{
121 auto* service = buffer_service();
122 const size_t old_bytes = m_stride * m_uses.size();
123 const size_t new_slots = m_uses.size() * 2;
124
125 auto grown = make_buffer(m_stride * new_slots, m_usage);
126 if (!grown || !grown->is_initialized() || !grown->get_mapped_ptr()) {
128 "SlotArena could not grow to {} slots", new_slots);
129 return false;
130 }
131
132 std::memcpy(grown->get_mapped_ptr(), m_buffer->get_mapped_ptr(), old_bytes);
133 service->flush_range(grown->get_buffer_resources().memory, 0, old_bytes);
134
135 service->retire_buffer(m_buffer);
136 m_buffer = std::move(grown);
137
138 m_uses.reserve(new_slots);
139 while (m_uses.size() < new_slots) {
140 m_uses.push_back(std::make_shared<std::atomic<uint32_t>>(0));
141 }
142
143 return true;
144}
145
146} // namespace MayaFlux::Portal::Graphics
#define MF_ERROR(comp, ctx,...)
#define MF_RT_ERROR(comp, ctx,...)
Portal::Graphics::BufferUsageHint Usage
Definition VKBuffer.hpp:80
vk::DescriptorBufferInfo info(size_t slot) const
Buffer, offset and range of a slot, ready for a descriptor write.
void write(size_t slot, const void *data, size_t size)
Copy bytes into a slot and flush them.
void release()
Release the buffer once the work submitted so far completes.
std::vector< std::shared_ptr< std::atomic< uint32_t > > > m_uses
SlotLease lease(size_t slot) const
Claim a slot until the returned lease and its copies are gone.
size_t acquire()
A slot nothing holds a lease on, growing the arena if none is free.
std::shared_ptr< Buffers::VKBuffer > m_buffer
bool initialize(size_t slot_bytes, BufferUsageHint usage, size_t slots=2)
Allocate the arena, releasing any previous buffer.
std::shared_ptr< Buffers::VKBuffer > detach()
Hand the buffer to the caller, leaving the arena empty.
A claim on one slot of a SlotArena for as long as the claim exists.
Interface * get_service()
Query for a backend service.
static BackendRegistry & instance()
Get the global registry instance.
@ BufferManagement
Buffer Management (Buffers::BufferManager, creating buffers).
@ Portal
High-level user-facing API layer.
@ UNKNOWN
Unknown or undefined modality.
Definition NDData.hpp:156
BufferUsageHint
Semantic usage hint for buffer allocation and memory properties.