g2px1/SharedStorage
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

code prettify

Browse Source
This commit is contained in:
g2px1 2025-04-20 23:32:04 +03:00
parent e2ae589a0e
commit 890b3403bb
12 changed files with 202 additions and 249 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

113
core/Command.cpp
View File

@ -6,78 +6,43 @@
namespace usub::core
{
// Command::Command() : op(OperationType::UNKNOWN), value_size(0), response_ready(0), response_size(0)
// {
// std::memset(value, 0, sizeof(value));
// std::memset(response, 0, sizeof(response));
// }
//
// Command::Command(const Command& other)
// : op(other.op),
// key(other.key),
// value_size(0),
// response_ready(false),
// response_size(0)
// {
// if (other.value_size > 0 && other.value_size <= sizeof(value))
// {
// value_size = other.value_size;
// std::memcpy(value, other.value, value_size);
// }
// if (other.response_size > 0 && other.response_size <= sizeof(response))
// {
// response_size = other.response_size;
// std::memcpy(response, other.response, response_size);
// }
// response_ready.store(other.response_ready.load(std::memory_order_relaxed), std::memory_order_relaxed);
// }
//
//
// Command::Command(Command&& other) noexcept
// : op(other.op),
// key(other.key),
// value_size(other.value_size),
// response_ready(other.response_ready.load(std::memory_order_relaxed)),
// response_size(other.response_size)
// {
// if (value_size > 0)
// std::memcpy(value, other.value, value_size);
// if (response_size > 0)
// std::memcpy(response, other.response, response_size);
// }
//
// Command& Command::operator=(const Command& other)
// {
// if (this != &other)
// {
// op = other.op;
// key = other.key;
// value_size = other.value_size;
// response_ready.store(other.response_ready.load(std::memory_order_relaxed), std::memory_order_relaxed);
// response_size = other.response_size;
//
// if (value_size > 0)
// std::memcpy(value, other.value, value_size);
// if (response_size > 0)
// std::memcpy(response, other.response, response_size);
// }
// return *this;
// }
//
// Command& Command::operator=(Command&& other) noexcept
// {
// if (this != &other)
// {
// op = other.op;
// key = other.key;
// value_size = other.value_size;
// response_ready.store(other.response_ready.load(std::memory_order_relaxed), std::memory_order_relaxed);
// response_size = other.response_size;
// if (value_size > 0)
// std::memcpy(value, other.value, value_size);
// if (response_size > 0)
// std::memcpy(response, other.response, response_size);
// }
// return *this;
// }
Command::Command()
{
ready.store(0, std::memory_order_relaxed);
response_ready.store(0, std::memory_order_relaxed);
op = OperationType::PUT;
key = utils::Hash128{};
value_size = 0;
response_size = 0;
}
Command::Command(const Command& other)
{
ready.store(other.ready.load(std::memory_order_relaxed), std::memory_order_relaxed);
op = other.op;
key = other.key;
value_size = other.value_size;
std::memcpy(value, other.value, other.value_size);
response_ready.store(other.response_ready.load(std::memory_order_relaxed), std::memory_order_relaxed);
response_size = other.response_size;
std::memcpy(response, other.response, other.response_size);
}
Command& Command::operator=(const Command& other)
{
if (this != &other)
{
ready.store(other.ready.load(std::memory_order_relaxed), std::memory_order_relaxed);
op = other.op;
key = other.key;
value_size = other.value_size;
std::memcpy(value, other.value, other.value_size);
response_ready.store(other.response_ready.load(std::memory_order_relaxed), std::memory_order_relaxed);
response_size = other.response_size;
std::memcpy(response, other.response, other.response_size);
}
return *this;
}
}

46
core/Command.h
View File

@ -21,6 +21,12 @@ namespace usub::core
struct Command
{
Command();
Command(const Command& other);
Command& operator=(const Command& other);
std::atomic<uint8_t> ready;
OperationType op;
utils::Hash128 key;
@ -30,46 +36,6 @@ namespace usub::core
std::atomic<uint8_t> response_ready;
uint32_t response_size;
char response[1024];
Command()
{
ready.store(0, std::memory_order_relaxed);
response_ready.store(0, std::memory_order_relaxed);
op = OperationType::PUT;
key = utils::Hash128{};
value_size = 0;
response_size = 0;
}
Command(const Command& other)
{
ready.store(other.ready.load(std::memory_order_relaxed), std::memory_order_relaxed);
op = other.op;
key = other.key;
value_size = other.value_size;
std::memcpy(value, other.value, other.value_size);
response_ready.store(other.response_ready.load(std::memory_order_relaxed), std::memory_order_relaxed);
response_size = other.response_size;
std::memcpy(response, other.response, other.response_size);
}
Command& operator=(const Command& other)
{
if (this != &other)
{
ready.store(other.ready.load(std::memory_order_relaxed), std::memory_order_relaxed);
op = other.op;
key = other.key;
value_size = other.value_size;
std::memcpy(value, other.value, other.value_size);
response_ready.store(other.response_ready.load(std::memory_order_relaxed), std::memory_order_relaxed);
response_size = other.response_size;
std::memcpy(response, other.response, other.response_size);
}
return *this;
}
};
}

6
core/DatabaseManager.cpp
View File

@ -36,13 +36,13 @@ namespace usub::core
}
bool create_new = !SharedMemoryManager::exists("shm_" + db_name);
auto udb = std::make_unique<UDB>(db_name, "shm_" + db_name, 1024, 1024 * 1024, create_new);
databases_.push_back(DatabaseInstance{std::move(udb), {}});
this->databases_.push_back(DatabaseInstance{std::move(udb), {}});
}
}
void DatabaseManager::run_all()
{
for (auto& db : databases_)
for (auto& db : this->databases_)
{
db.worker = std::thread([&db]()
{
@ -50,7 +50,7 @@ namespace usub::core
});
}
for (auto& db : databases_)
for (auto& db : this->databases_)
{
if (db.worker.joinable())
db.worker.join();

16
core/Memtable.h
View File

@ -66,8 +66,8 @@ namespace usub::shared_storage
const typename SkipList::value_type& value)
{
{
std::lock_guard<std::mutex> lock(batch_mutex);
write_batch.emplace_back(key, value);
std::lock_guard<std::mutex> lock(this->batch_mutex);
this->write_batch.emplace_back(key, value);
}
if (estimate_batch_size() >= 64)
{
@ -110,17 +110,17 @@ namespace usub::shared_storage
{
std::vector<std::pair<typename SkipList::key_type, typename SkipList::value_type>> local_batch;
{
std::lock_guard<std::mutex> lock(batch_mutex);
local_batch.swap(write_batch);
std::lock_guard<std::mutex> lock(this->batch_mutex);
local_batch.swap(this->write_batch);
}
for (const auto& [key, value] : local_batch)
{
wal.write_put(key, value);
active_memtable.load()->insert(key, value);
this->wal.write_put(key, value);
this->active_memtable.load()->insert(key, value);
}
if (estimate_memtable_size() > max_memtable_size)
if (estimate_memtable_size() > this->max_memtable_size)
{
flush();
}
@ -136,7 +136,7 @@ namespace usub::shared_storage
template <typename SkipList>
size_t MemTableManager<SkipList>::estimate_batch_size() const
{
return write_batch.size();
return this->write_batch.size();
}
} // shared_storage
// usub

128
core/SharedCommandQueue.cpp
View File

@ -9,27 +9,27 @@ namespace usub::core
SharedCommandQueue::SharedCommandQueue(size_t capacity)
: capacity_(capacity), head_(0), tail_(0)
{
for (size_t i = 0; i < capacity_; ++i)
new(&buffer_[i]) Command();
for (size_t i = 0; i < this->capacity_; ++i)
new(&this->buffer_[i]) Command();
}
SharedCommandQueue::~SharedCommandQueue()
{
for (size_t i = 0; i < capacity_; ++i)
for (size_t i = 0; i < this->capacity_; ++i)
{
buffer_[i].~Command();
this->buffer_[i].~Command();
}
}
bool SharedCommandQueue::try_push(const Command& cmd)
{
size_t head = head_.load(std::memory_order_relaxed);
size_t next_head = (head + 1) % capacity_;
size_t head = this->head_.load(std::memory_order_relaxed);
size_t next_head = (head + 1) % this->capacity_;
if (next_head == tail_.load(std::memory_order_acquire))
if (next_head == this->tail_.load(std::memory_order_acquire))
return false; // Очередь полна
Command& slot = buffer_[head];
Command& slot = this->buffer_[head];
slot.ready.store(0, std::memory_order_relaxed);
slot.op = cmd.op;
slot.key = cmd.key;
@ -37,25 +37,25 @@ namespace usub::core
std::memcpy(slot.value, cmd.value, cmd.value_size);
slot.response_size = 0;
slot.response_ready.store(0, std::memory_order_relaxed);
head_.store(next_head, std::memory_order_release);
this->head_.store(next_head, std::memory_order_release);
return true;
}
bool SharedCommandQueue::try_push_batch(const Command* cmds, size_t count)
{
size_t head = head_.load(std::memory_order_relaxed);
size_t tail = tail_.load(std::memory_order_acquire);
size_t head = this->head_.load(std::memory_order_relaxed);
size_t tail = this->tail_.load(std::memory_order_acquire);
size_t free_slots = (tail + capacity_ - head) % capacity_;
size_t free_slots = (tail + this->capacity_ - head) % this->capacity_;
if (free_slots < count)
return false;
for (size_t i = 0; i < count; ++i)
{
Command& slot = buffer_[(head + i) % capacity_];
Command& slot = this->buffer_[(head + i) % this->capacity_];
slot = cmds[i];
}
head_.store((head + count) % capacity_, std::memory_order_release);
this->head_.store((head + count) % this->capacity_, std::memory_order_release);
return true;
}
@ -66,32 +66,32 @@ namespace usub::core
std::optional<Command> SharedCommandQueue::try_pop()
{
size_t tail = tail_.load(std::memory_order_relaxed);
size_t tail = this->tail_.load(std::memory_order_relaxed);
if (tail == head_.load(std::memory_order_acquire))
if (tail == this->head_.load(std::memory_order_acquire))
{
return std::nullopt;
}
Command& slot = buffer_[tail];
Command& slot = this->buffer_[tail];
Command cmd = slot;
tail_.store((tail + 1) % capacity_, std::memory_order_release);
this->tail_.store((tail + 1) % this->capacity_, std::memory_order_release);
return cmd;
}
size_t SharedCommandQueue::try_pop_batch(Command* out, size_t max_count)
{
size_t tail = tail_.load(std::memory_order_relaxed);
size_t head = head_.load(std::memory_order_acquire);
size_t tail = this->tail_.load(std::memory_order_relaxed);
size_t head = this->head_.load(std::memory_order_acquire);
size_t available = (head + capacity_ - tail) % capacity_;
size_t available = (head + this->capacity_ - tail) % this->capacity_;
size_t to_pop = (available < max_count) ? available : max_count;
size_t copied = 0;
for (size_t i = 0; i < to_pop; ++i)
{
Command& src = buffer_[(tail + i) % capacity_];
Command& src = this->buffer_[(tail + i) % this->capacity_];
if (src.ready.load(std::memory_order_acquire) == 0)
break;
@ -99,31 +99,97 @@ namespace usub::core
out[copied++] = src;
}
tail_.store((tail + copied) % capacity_, std::memory_order_release);
this->tail_.store((tail + copied) % this->capacity_, std::memory_order_release);
return copied;
}
Command* SharedCommandQueue::peek(size_t index)
{
size_t tail = tail_.load(std::memory_order_relaxed);
size_t head = head_.load(std::memory_order_acquire);
size_t tail = this->tail_.load(std::memory_order_relaxed);
size_t head = this->head_.load(std::memory_order_acquire);
if (tail == head)
return nullptr;
return &buffer_[tail % capacity_];
return &this->buffer_[tail % this->capacity_];
}
void SharedCommandQueue::pop()
{
size_t tail = tail_.load(std::memory_order_relaxed);
tail_.store((tail + 1) % capacity_, std::memory_order_release);
size_t tail = this->tail_.load(std::memory_order_relaxed);
this->tail_.store((tail + 1) % this->capacity_, std::memory_order_release);
}
size_t SharedCommandQueue::pending_count() const
{
size_t head = head_.load(std::memory_order_acquire);
size_t tail = tail_.load(std::memory_order_relaxed);
return (head + capacity_ - tail) % capacity_;
size_t head = this->head_.load(std::memory_order_acquire);
size_t tail = this->tail_.load(std::memory_order_relaxed);
return (head + this->capacity_ - tail) % this->capacity_;
}
Command* SharedCommandQueue::raw_buffer() noexcept
{
return this->buffer_;
}
size_t SharedCommandQueue::capacity() const noexcept
{
return this->capacity_;
}
std::atomic<size_t>& SharedCommandQueue::head() noexcept
{
return this->head_;
}
std::atomic<size_t>& SharedCommandQueue::tail() noexcept
{
return this->tail_;
}
bool SharedCommandQueue::enqueue_put(const usub::utils::Hash128& key, const std::string& value)
{
size_t head = this->head_.load(std::memory_order_relaxed);
size_t next_head = (head + 1) % this->capacity_;
if (next_head == this->tail_.load(std::memory_order_acquire))
return false;
Command& slot = this->buffer_[head];
slot.op = OperationType::PUT;
slot.key = key;
slot.value_size = static_cast<uint32_t>(value.size());
std::memcpy(slot.value, value.data(), value.size());
slot.response_size = 0;
slot.response_ready.store(0, std::memory_order_relaxed);
slot.ready.store(1, std::memory_order_release);
this->head_.store(next_head, std::memory_order_release);
return true;
}
bool SharedCommandQueue::enqueue_find(const utils::Hash128& key)
{
size_t head = this->head_.load(std::memory_order_relaxed);
size_t next_head = (head + 1) % capacity_;
if (next_head == this->tail_.load(std::memory_order_acquire))
return false;
Command& slot = buffer_[head];
slot.op = OperationType::FIND;
slot.key = key;
slot.value_size = 0;
slot.response_size = 0;
slot.response_ready.store(0, std::memory_order_relaxed);
slot.ready.store(1, std::memory_order_release);
this->head_.store(next_head, std::memory_order_release);
return true;
}
bool SharedCommandQueue::await_response(Command& cmd)
{
while (cmd.response_ready.load(std::memory_order_acquire) == 0)
std::this_thread::sleep_for(std::chrono::milliseconds(1));
return cmd.response_size != 0;
}
}

51
core/SharedCommandQueue.h
View File

@ -37,56 +37,19 @@ namespace usub::core
size_t pending_count() const;
Command* raw_buffer() noexcept { return buffer_; }
size_t capacity() const noexcept { return capacity_; }
std::atomic<size_t>& head() noexcept { return head_; }
std::atomic<size_t>& tail() noexcept { return tail_; }
Command* raw_buffer() noexcept;
bool enqueue_put(const usub::utils::Hash128& key, const std::string& value)
{
size_t head = head_.load(std::memory_order_relaxed);
size_t next_head = (head + 1) % capacity_;
if (next_head == tail_.load(std::memory_order_acquire))
return false;
size_t capacity() const noexcept;
Command& slot = buffer_[head];
slot.op = OperationType::PUT;
slot.key = key;
slot.value_size = static_cast<uint32_t>(value.size());
std::memcpy(slot.value, value.data(), value.size());
slot.response_size = 0;
slot.response_ready.store(0, std::memory_order_relaxed);
slot.ready.store(1, std::memory_order_release);
std::atomic<size_t>& head() noexcept;
head_.store(next_head, std::memory_order_release);
return true;
}
std::atomic<size_t>& tail() noexcept;
bool enqueue_find(const usub::utils::Hash128& key)
{
size_t head = head_.load(std::memory_order_relaxed);
size_t next_head = (head + 1) % capacity_;
if (next_head == tail_.load(std::memory_order_acquire))
return false;
bool enqueue_put(const usub::utils::Hash128& key, const std::string& value);
Command& slot = buffer_[head];
slot.op = OperationType::FIND;
slot.key = key;
slot.value_size = 0;
slot.response_size = 0;
slot.response_ready.store(0, std::memory_order_relaxed);
slot.ready.store(1, std::memory_order_release);
bool enqueue_find(const usub::utils::Hash128& key);
head_.store(next_head, std::memory_order_release);
return true;
}
bool await_response(Command& cmd)
{
while (cmd.response_ready.load(std::memory_order_acquire) == 0)
std::this_thread::sleep_for(std::chrono::milliseconds(1));
return cmd.response_size != 0;
}
bool await_response(Command& cmd);
private:
size_t capacity_;

2
core/UDB.cpp
View File

@ -41,7 +41,7 @@ namespace usub::core
void UDB::recover_from_logs()
{
utils::RecoveryLog recovery_log(db_name_);
utils::RecoveryLog recovery_log(this->db_name_);
recovery_log.replay([this](const utils::Hash128& key, const std::string& value, bool is_tombstone)
{

13
main.cpp
View File

@ -9,6 +9,7 @@
using namespace usub::utils;
#if 0
#include "utils/io/VersionManager.h"
void test_skiplist_basic()
@ -76,20 +77,10 @@ void test_sstable_write_read()
std::cout << "SSTable write/read test passed.\n";
}
#include "utils/datastructures/LFCircullarBuffer.h"
#include "core/SharedMemoryManager.h"
#include "core/SharedCommandQueue.h"
#include "utils/datastructures/LFCircullarBuffer.h"
#include "core/Command.h"
#include "utils/hash/Hash128.h"
#include <unordered_map>
#include "utils/string/basic_utils.h"
#endif
#include "core/DatabaseManager.h"
int main()
{
#if 0

10
utils/datastructures/LFCircullarBuffer.h
View File

@ -66,13 +66,13 @@ namespace usub::utils
explicit LockFreeRingBuffer(size_t cap = 32)
: capacity(cap), mask(cap - 1), buffer(new Cell[cap])
{
if ((capacity & (capacity - 1)) != 0)
if ((this->capacity & (this->capacity - 1)) != 0)
{
throw std::invalid_argument("Capacity must be a power of 2");
}
for (size_t i = 0; i < capacity; ++i)
for (size_t i = 0; i < this->capacity; ++i)
{
buffer[i].sequence.store(i, std::memory_order_relaxed);
this->buffer[i].sequence.store(i, std::memory_order_relaxed);
}
}
@ -81,7 +81,7 @@ namespace usub::utils
while (pop())
{
}
delete[] buffer;
delete[] this->buffer;
}
template <typename U>
@ -188,7 +188,7 @@ namespace usub::utils
return (h - t) & mask;
}
[[nodiscard]] size_t get_capacity() const noexcept { return capacity; }
[[nodiscard]] size_t get_capacity() const noexcept { return this->capacity; }
};
}

20
utils/datastructures/LFSkipList.h
View File

@ -31,6 +31,7 @@ namespace usub::utils
template <typename Key, typename Value>
class LFSkipList
{
private:
struct Node
{
Key key;
@ -45,7 +46,7 @@ namespace usub::utils
: key(k), value(v), topLevel(level), is_tombstone(tombstone), version(ver)
{
for (int i = 0; i < MAX_LEVEL; ++i)
next[i].store(nullptr, std::memory_order_relaxed);
this->next[i].store(nullptr, std::memory_order_relaxed);
}
};
@ -59,12 +60,13 @@ namespace usub::utils
LFSkipList(usub::utils::VersionManager& vm)
: version_manager(vm)
{
head = new Node(std::numeric_limits<Key>::min(), Value{}, MAX_LEVEL, false, version_manager.next_version());
this->head = new Node(std::numeric_limits<Key>::min(), Value{}, MAX_LEVEL, false,
this->version_manager.next_version());
}
~LFSkipList()
{
Node* curr = head;
Node* curr = this->head;
while (curr)
{
Node* next = next_node(curr->next[0].load(std::memory_order_relaxed));
@ -86,7 +88,7 @@ namespace usub::utils
std::optional<Value> find(const Key& key) const
{
Node* best = nullptr;
Node* node = head->next[0].load(std::memory_order_acquire);
Node* node = this->head->next[0].load(std::memory_order_acquire);
while (node)
{
@ -109,7 +111,7 @@ namespace usub::utils
template <typename F>
void for_each(F&& func) const
{
Node* node = head->next[0].load(std::memory_order_acquire);
Node* node = this->head->next[0].load(std::memory_order_acquire);
while (node)
{
prefetch_for_read(node);
@ -124,7 +126,7 @@ namespace usub::utils
template <typename F>
void for_each_raw(F&& func) const
{
Node* node = head->next[0].load(std::memory_order_acquire);
Node* node = this->head->next[0].load(std::memory_order_acquire);
while (node)
{
prefetch_for_read(node);
@ -178,7 +180,7 @@ namespace usub::utils
[[nodiscard]] size_t unsafe_size() const
{
size_t count = 0;
Node* node = head->next[0].load(std::memory_order_relaxed);
Node* node = this->head->next[0].load(std::memory_order_relaxed);
while (node)
{
if (!node->marked.load(std::memory_order_relaxed) && !node->is_tombstone)
@ -199,7 +201,7 @@ namespace usub::utils
bool found = find_internal(key, preds, succs);
int topLevel = random_level();
Node* newNode = new Node(key, value, topLevel, tombstone, version_manager.next_version());
Node* newNode = new Node(key, value, topLevel, tombstone, this->version_manager.next_version());
for (int i = 0; i < topLevel; ++i)
newNode->next[i].store(succs[i], std::memory_order_relaxed);
@ -231,7 +233,7 @@ namespace usub::utils
bool find_internal(const Key& key, Node** preds, Node** succs) const
{
bool found = false;
Node* pred = head;
Node* pred = this->head;
for (int level = MAX_LEVEL - 1; level >= 0; --level)
{

42
utils/io/Compactor.cpp
View File

@ -15,33 +15,33 @@ namespace usub::utils
Compactor::~Compactor()
{
running_ = false;
if (worker_thread_.joinable())
worker_thread_.join();
this->running_ = false;
if (this->worker_thread_.joinable())
this->worker_thread_.join();
}
void Compactor::add_sstable_l0(const std::string& filename)
{
l0_queue_.push(filename);
this->l0_queue_.push(filename);
}
void Compactor::run()
{
worker_thread_ = std::thread(&Compactor::background_worker, this);
this->worker_thread_ = std::thread(&Compactor::background_worker, this);
}
void Compactor::background_worker()
{
while (running_)
while (this->running_)
{
for (size_t i = 0; i < 8; ++i)
{
auto file = l0_queue_.pop();
auto file = this->l0_queue_.pop();
if (file)
{
std::lock_guard<std::mutex> lock(levels_mutex_);
level0_files_.push_back(*file);
level0_size_.fetch_add(1, std::memory_order_relaxed); // увеличиваем счётчик
std::lock_guard<std::mutex> lock(this->levels_mutex_);
this->level0_files_.push_back(*file);
this->level0_size_.fetch_add(1, std::memory_order_relaxed); // увеличиваем счётчик
}
else
{
@ -49,16 +49,16 @@ namespace usub::utils
}
}
if (level0_size_.load(std::memory_order_relaxed) >= 4)
if (this->level0_size_.load(std::memory_order_relaxed) >= 4)
{
std::lock_guard<std::mutex> lock(levels_mutex_);
compact_level(level0_files_, level1_files_, 0);
std::lock_guard<std::mutex> lock(this->levels_mutex_);
compact_level(this->level0_files_, this->level1_files_, 0);
}
if (level1_size_.load(std::memory_order_relaxed) >= 4)
{
std::lock_guard<std::mutex> lock(levels_mutex_);
compact_level(level1_files_, level2_files_, 1);
std::lock_guard<std::mutex> lock(this->levels_mutex_);
compact_level(this->level1_files_, this->level2_files_, 1);
}
std::this_thread::sleep_for(std::chrono::milliseconds(50));
@ -87,7 +87,7 @@ namespace usub::utils
std::filesystem::remove(file);
}
LFSkipList<Hash128, std::string> merged(version_manager_);
LFSkipList<Hash128, std::string> merged(this->version_manager_);
for (auto& table : loaded)
{
@ -101,7 +101,7 @@ namespace usub::utils
}
std::string new_filename = "sstable_l" + std::to_string(level + 1) + "_" +
std::to_string(version_manager_.next_version()) + ".dat";
std::to_string(this->version_manager_.next_version()) + ".dat";
write_sstable_with_index(merged, new_filename);
dest_files.push_back(new_filename);
@ -110,13 +110,13 @@ namespace usub::utils
if (level == 0)
{
level0_size_.fetch_sub(batch_size, std::memory_order_relaxed);
level1_size_.fetch_add(1, std::memory_order_relaxed);
this->level0_size_.fetch_sub(batch_size, std::memory_order_relaxed);
this->level1_size_.fetch_add(1, std::memory_order_relaxed);
}
else if (level == 1)
{
level1_size_.fetch_sub(batch_size, std::memory_order_relaxed);
level2_size_.fetch_add(1, std::memory_order_relaxed);
this->level1_size_.fetch_sub(batch_size, std::memory_order_relaxed);
this->level2_size_.fetch_add(1, std::memory_order_relaxed);
}
}
} // utils

4
utils/io/VersionManager.cpp
View File

@ -8,8 +8,8 @@ namespace usub::utils
{
VersionManager::VersionManager(const std::string& dbname)
: db_name(dbname),
metadata_dir("metadata/" + db_name + "/"),
version_file(metadata_dir + "version.meta")
metadata_dir("metadata/" + this->db_name + "/"),
version_file(this->metadata_dir + "version.meta")
{
ensure_metadata_dir();
load_version();