srs-control 0.2.2
Loading...
Searching...
No Matches
BufferQueue.cpp
Go to the documentation of this file.
1#include "BufferQueue.hpp"
4#include <atomic>
5#include <cstddef>
6#include <fmt/format.h>
7#include <iterator>
8#include <ranges>
9#include <spdlog/spdlog.h>
10#include <string>
11#include <utility>
12#include <vector>
13
14namespace srs
15{
17 : config_{ config }
18 , valid_buffer_queue_{ config.queue_capacity }
19 , trash_buffer_queue_{ config.queue_capacity }
20 {
21
23 for (const auto _ : std::views::iota(std::size_t{ 0 }, config_.reserve_size))
24 {
25 if (not trash_buffer_queue_.try_enqueue(internal_trash_buffer_token_, LargeBuffer{ config_.buffer_size }))
26 {
27 break;
28 }
29 }
30 spdlog::debug("Memory preallocation finished.");
31 }
32
34 {
35 const auto bytes_alloc = config_.buffer_size * config_.reserve_size;
36 auto print_str = std::string{};
37 if (bytes_alloc < 1000'000)
38 {
39 print_str = fmt::format("{} KB", bytes_alloc / 1000);
40 }
41 else if (bytes_alloc < 1000'000'000)
42 {
43 print_str = fmt::format("{} MB", bytes_alloc / 1000'000);
44 }
45 else
46 {
47 print_str = fmt::format("{} GB", bytes_alloc / 1000'000'000);
48 }
49 spdlog::info("Trying to pre-allocate {} memory for the buffer queue ...", print_str);
50 }
51 void BufferQueue::enqueue_empty(std::size_t bulk_size)
52 {
53 auto buffers = std::vector<LargeBuffer>{};
54 for (auto _ : std::views::iota(std::size_t{ 0 }, bulk_size))
55 {
56 buffers.emplace_back();
57 }
58 valid_buffer_queue_.enqueue_bulk(
59 internal_valid_buffer_token_, std::make_move_iterator(buffers.begin()), bulk_size);
60 }
61
62 // NOTE: try_enqueue will use move constructor, which performs swap operator
63 auto BufferQueue::enqueue(LargeBuffer& element, Token& token) -> bool
64 {
65 if (not valid_buffer_queue_.try_enqueue(token.first, std::move(element)))
66 {
68 return false;
69 }
70
71 if (not trash_buffer_queue_.try_dequeue(token.second, element))
72 {
74 element.resize(config_.buffer_size);
75 }
76 return true;
77 }
78
79 // block
80 void BufferQueue::dequeue(LargeBuffer& element, Token& token)
81 {
82 if (not trash_buffer_queue_.try_enqueue(token.first, std::move(element)))
83 {
85 }
86 valid_buffer_queue_.wait_dequeue(token.second, element);
87 }
88
90 {
91 report.register_queue_result({ .empty_trash = n_trash_recycle_empty_failures_.load(std::memory_order_relaxed),
92 .full_trash = n_trash_recycle_full_failures_.load(std::memory_order_relaxed),
93 .full_valid = n_valid_buffer_full_failures_.load(std::memory_order_relaxed) });
94 }
95} // namespace srs
void register_queue_result(const QueueStat &stat)
Definition AppReport.hpp:68
void register_report(AppReport &report)
std::atomic< std::size_t > n_trash_recycle_empty_failures_
std::atomic< std::size_t > n_trash_recycle_full_failures_
auto enqueue(LargeBuffer &element, Token &token) -> bool
Try to first push a buffer into the valid buffer queue and then replace it with a buffer from the tra...
std::atomic< std::size_t > n_valid_buffer_full_failures_
std::pair< moodycamel::ProducerToken, moodycamel::ConsumerToken > Token
A queue token type used for enqueue and dequeue action. The token type consists of one producer token...
moodycamel::BlockingConcurrentQueue< LargeBuffer > valid_buffer_queue_
moodycamel::ConcurrentQueue< LargeBuffer > trash_buffer_queue_
BufferQueue(const Config &config)
Default constructor.
void dequeue(LargeBuffer &element, Token &token)
Blocking the current thread by first pushing the element to the trash buffer queue and then replacing...
void print_memory_pre_allocation()
moodycamel::ProducerToken internal_trash_buffer_token_
moodycamel::ProducerToken internal_valid_buffer_token_
void enqueue_empty(std::size_t bulk_size)
Abort the blocking operation from BufferQueue::pop().
Class for buffer for storing large data.
Configuration for the buffer queue class.