1
0
mirror of https://github.com/danog/ton.git synced 2024-12-12 17:17:22 +01:00
ton/tdutils/td/utils/queue.h
2019-09-07 14:33:36 +04:00

485 lines
9.8 KiB
C++

/*
This file is part of TON Blockchain Library.
TON Blockchain Library is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
TON Blockchain Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with TON Blockchain Library. If not, see <http://www.gnu.org/licenses/>.
Copyright 2017-2019 Telegram Systems LLP
*/
#pragma once
#include "td/utils/port/EventFd.h"
#include "td/utils/port/thread.h"
#if !TD_THREAD_UNSUPPORTED && !TD_EVENTFD_UNSUPPORTED
#include <atomic>
#include <type_traits>
#include <utility>
namespace td {
namespace detail {
class Backoff {
int cnt = 0;
public:
bool next() {
// TODO: find out better strategy
// TODO: try adaptive backoff
// TODO: different strategy one core cpu
// return false;
cnt++;
if (cnt < 1) { // 50
return true;
} else {
td::this_thread::yield();
return cnt < 3; // 500
}
}
};
class InfBackoff {
int cnt = 0;
public:
bool next() {
cnt++;
if (cnt < 50) {
return true;
} else {
td::this_thread::yield();
return true;
}
}
};
} // namespace detail
template <class T, int P = 10>
class SPSCBlockQueue {
public:
using ValueType = T;
private:
static constexpr int buffer_size() {
static_assert(P >= 1 && P <= 20, "Bad size of BlockQueue");
return 1 << P;
}
struct Position {
std::atomic<uint32> i{0};
char pad[64 - sizeof(std::atomic<uint32>)];
uint32 local_writer_i;
char pad2[64 - sizeof(uint32)];
uint32 local_reader_i;
char pad3[64 - sizeof(uint32)];
void init() {
i = 0;
local_reader_i = 0;
local_writer_i = 0;
}
};
typename std::aligned_storage<sizeof(ValueType)>::type data_[buffer_size()];
Position writer_;
Position reader_;
static int fix_i(int i) {
return i & (buffer_size() - 1);
}
ValueType *at_ptr(int i) {
return reinterpret_cast<ValueType *>(&data_[fix_i(i)]);
}
ValueType &at(int i) {
return *at_ptr(i);
}
public:
void init() {
writer_.init();
reader_.init();
}
void destroy() {
}
int writer_size() {
return static_cast<int>(writer_.local_reader_i + buffer_size() - writer_.local_writer_i);
}
bool writer_empty() {
return writer_.local_reader_i + buffer_size() == writer_.local_writer_i;
}
template <class PutValueType>
void writer_put_unsafe(PutValueType &&value) {
at(writer_.local_writer_i++) = std::forward<PutValueType>(value);
}
int writer_update() {
writer_.local_reader_i = reader_.i.load(std::memory_order_acquire);
return writer_size();
}
void writer_flush() {
writer_.i.store(writer_.local_writer_i, std::memory_order_release);
}
int reader_size() {
return static_cast<int>(reader_.local_writer_i - reader_.local_reader_i);
}
int reader_empty() {
return reader_.local_writer_i == reader_.local_reader_i;
}
ValueType reader_get_unsafe() {
return std::move(at(reader_.local_reader_i++));
}
int reader_update() {
reader_.local_writer_i = writer_.i.load(std::memory_order_acquire);
return reader_size();
}
void reader_flush() {
reader_.i.store(reader_.local_reader_i, std::memory_order_release);
}
};
template <class T, class BlockQueueT = SPSCBlockQueue<T> >
class SPSCChainQueue {
public:
using ValueType = T;
void init() {
head_ = tail_ = create_node();
}
SPSCChainQueue() = default;
SPSCChainQueue(const SPSCChainQueue &) = delete;
SPSCChainQueue &operator=(const SPSCChainQueue &) = delete;
SPSCChainQueue(SPSCChainQueue &&) = delete;
SPSCChainQueue &operator=(SPSCChainQueue &&) = delete;
~SPSCChainQueue() {
destroy();
}
void destroy() {
while (head_ != nullptr) {
Node *to_delete = head_;
head_ = head_->next_;
delete_node(to_delete);
}
tail_ = nullptr;
}
int writer_size() {
return tail_->q_.writer_size();
}
bool writer_empty() {
return tail_->q_.writer_empty();
}
template <class PutValueType>
void writer_put_unsafe(PutValueType &&value) {
tail_->q_.writer_put_unsafe(std::forward<PutValueType>(value));
}
int writer_update() {
int res = tail_->q_.writer_update();
if (res != 0) {
return res;
}
writer_flush();
Node *new_tail = create_node();
tail_->next_ = new_tail;
tail_->is_closed_.store(true, std::memory_order_release);
tail_ = new_tail;
return tail_->q_.writer_update();
}
void writer_flush() {
tail_->q_.writer_flush();
}
int reader_size() {
return head_->q_.reader_size();
}
int reader_empty() {
return head_->q_.reader_empty();
}
ValueType reader_get_unsafe() {
return std::move(head_->q_.reader_get_unsafe());
}
int reader_update() {
int res = head_->q_.reader_update();
if (res != 0) {
return res;
}
if (!head_->is_closed_.load(std::memory_order_acquire)) {
return 0;
}
res = head_->q_.reader_update();
if (res != 0) {
return res;
}
// reader_flush();
Node *old_head = head_;
head_ = head_->next_;
delete_node(old_head);
return head_->q_.reader_update();
}
void reader_flush() {
head_->q_.reader_flush();
}
private:
struct Node {
BlockQueueT q_;
std::atomic<bool> is_closed_{false};
Node *next_;
void init() {
q_.init();
is_closed_ = false;
next_ = nullptr;
}
void destroy() {
q_.destroy();
next_ = nullptr;
}
};
Node *head_;
char pad[64 - sizeof(Node *)];
Node *tail_;
char pad2[64 - sizeof(Node *)];
Node *create_node() {
Node *res = new Node();
res->init();
return res;
}
void delete_node(Node *node) {
node->destroy();
delete node;
}
};
template <class T, class QueueT = SPSCChainQueue<T>, class BackoffT = detail::Backoff>
class BackoffQueue : public QueueT {
public:
using ValueType = T;
template <class PutValueType>
void writer_put(PutValueType &&value) {
if (this->writer_empty()) {
int sz = this->writer_update();
CHECK(sz != 0);
}
this->writer_put_unsafe(std::forward<PutValueType>(value));
}
int reader_wait() {
BackoffT backoff;
int res = 0;
do {
res = this->reader_update();
} while (res == 0 && backoff.next());
return res;
}
};
template <class T, class QueueT = SPSCChainQueue<T> >
using InfBackoffQueue = BackoffQueue<T, QueueT, detail::InfBackoff>;
template <class T, class QueueT = BackoffQueue<T> >
class PollQueue : public QueueT {
public:
using ValueType = T;
using QueueType = QueueT;
void init() {
QueueType::init();
event_fd_.init();
wait_state_ = 0;
writer_wait_state_ = 0;
}
PollQueue() = default;
PollQueue(const PollQueue &) = delete;
PollQueue &operator=(const PollQueue &) = delete;
PollQueue(PollQueue &&) = delete;
PollQueue &operator=(PollQueue &&) = delete;
~PollQueue() {
destroy_impl();
}
void destroy() {
destroy_impl();
QueueType::destroy();
}
void writer_flush() {
int old_wait_state = get_wait_state();
std::atomic_thread_fence(std::memory_order_seq_cst);
QueueType::writer_flush();
std::atomic_thread_fence(std::memory_order_seq_cst);
int wait_state = get_wait_state();
if ((wait_state & 1) && wait_state != writer_wait_state_) {
event_fd_.release();
writer_wait_state_ = old_wait_state;
}
}
EventFd &reader_get_event_fd() {
return event_fd_;
}
// if 0 is returned than it is useless to rerun it before fd is
// ready to read.
int reader_wait_nonblock() {
int res;
if ((get_wait_state() & 1) == 0) {
res = this->QueueType::reader_wait();
if (res != 0) {
return res;
}
inc_wait_state();
std::atomic_thread_fence(std::memory_order_seq_cst);
res = this->reader_update();
if (res != 0) {
inc_wait_state();
return res;
}
}
event_fd_.acquire();
std::atomic_thread_fence(std::memory_order_seq_cst);
res = this->reader_update();
if (res != 0) {
inc_wait_state();
}
return res;
}
// Just an example of usage
int reader_wait() {
int res;
while ((res = reader_wait_nonblock()) == 0) {
reader_get_event_fd().wait(1000);
}
return res;
}
private:
EventFd event_fd_;
std::atomic<int> wait_state_{0};
int writer_wait_state_;
int get_wait_state() {
return wait_state_.load(std::memory_order_relaxed);
}
void inc_wait_state() {
wait_state_.store(get_wait_state() + 1, std::memory_order_relaxed);
}
void destroy_impl() {
if (!event_fd_.empty()) {
event_fd_.close();
}
}
};
} // namespace td
#else
#include "td/utils/common.h"
namespace td {
// dummy implementation which shouldn't be used
template <class T>
class PollQueue {
public:
using ValueType = T;
void init() {
UNREACHABLE();
}
template <class PutValueType>
void writer_put(PutValueType &&value) {
UNREACHABLE();
}
void writer_flush() {
UNREACHABLE();
}
int reader_wait_nonblock() {
UNREACHABLE();
return 0;
}
ValueType reader_get_unsafe() {
UNREACHABLE();
return ValueType();
}
void reader_flush() {
UNREACHABLE();
}
PollQueue() = default;
PollQueue(const PollQueue &) = delete;
PollQueue &operator=(const PollQueue &) = delete;
PollQueue(PollQueue &&) = delete;
PollQueue &operator=(PollQueue &&) = delete;
~PollQueue() = default;
};
} // namespace td
#endif