rrudb 0.0.2

data/ext/rudb/NuDB/include/nudb/impl/context.ipp

@@ -0,0 +1,241 @@
+//
+// Copyright (c) 2019 Miguel Portilla (miguelportilla64 at gmail dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef NUDB_IMPL_CONTEXT_IPP
+#define NUDB_IMPL_CONTEXT_IPP
+
+#include <nudb/detail/store_base.hpp>
+
+namespace nudb {
+
+context::
+~context() noexcept (false)
+{
+    stop_all();
+    std::lock_guard<std::mutex> lock(m_);
+    if(! waiting_.empty() || ! flushing_.empty())
+        throw std::logic_error("All databases haven't been closed");
+}
+
+void
+context::
+start()
+{
+    std::lock_guard<std::mutex> lock(m_);
+    if(! stop_ && ! t_.joinable())
+        t_ = std::thread(&context::run, this);
+}
+
+void
+context::
+stop_all()
+{
+    std::unique_lock<std::mutex> lock(m_);
+    if(stop_)
+        return;
+    stop_ = true;
+    cv_f_.notify_all();
+    cv_w_.notify_all();
+    cv_w_.wait(lock,
+        [&]
+        {
+            return num_threads_ == 0;
+        });
+    if(t_.joinable())
+    {
+        lock.unlock();
+        t_.join();
+        lock.lock();
+    }
+    stop_ = false;
+}
+
+void
+context::
+run()
+{
+    bool const first = [&]
+    {
+        std::lock_guard<std::mutex> lock(m_);
+        return ++num_threads_ == 1;
+    }();
+
+    auto when = clock_type::now();
+    for(;;)
+    {
+        {
+            std::unique_lock<std::mutex> lock(m_);
+            if(stop_)
+                break;
+            if(first)
+            {
+                auto const status = cv_f_.wait_until(
+                    lock, when + std::chrono::seconds{1});
+                if(stop_)
+                    break;
+                if(status == std::cv_status::timeout && ! waiting_.empty())
+                {
+                    // Move everything in waiting_ to flushing_
+                    for(auto store = waiting_.head_; store;
+                        store = store->next_)
+                        store->state_ = store_base::state::flushing;
+                    flushing_.splice(waiting_);
+                }
+
+                when = clock_type::now();
+                if(flushing_.empty())
+                    continue;
+                cv_f_.notify_all();
+            }
+            else
+            {
+                cv_f_.wait(lock,
+                    [this]
+                    {
+                        return ! flushing_.empty() || stop_;
+                    });
+                if(stop_)
+                    break;
+            }
+        }
+
+        // process everything in flushing_
+        for(;;)
+            if(! flush_one())
+                break;
+    }
+
+    std::lock_guard<std::mutex> lock(m_);
+    --num_threads_;
+    cv_w_.notify_all();
+}
+
+void
+context::
+insert(store_base& store)
+{
+    std::lock_guard<std::mutex> lock(m_);
+    store.state_ = store_base::state::waiting;
+    waiting_.push_back(&store);
+    cv_w_.notify_all();
+}
+
+void
+context::
+erase(store_base& store)
+{
+    using state = store_base::state;
+    std::unique_lock<std::mutex> lock(m_);
+    switch(store.state_)
+    {
+    case state::waiting:
+        waiting_.erase(&store);
+        cv_w_.notify_all();
+        break;
+    case state::flushing:
+        flushing_.erase(&store);
+        break;
+    case state::intermediate:
+        cv_w_.wait(lock,
+            [&]
+            {
+                return store.state_ != state::intermediate;
+            });
+        if(store.state_ == state::flushing)
+        {
+            flushing_.erase(&store);
+        }
+        else if(store.state_ == state::waiting)
+        {
+            waiting_.erase(&store);
+            cv_w_.notify_all();
+        }
+        break;
+    case state::none:
+        return;
+    }
+    store.state_ = state::none;
+}
+
+bool
+context::
+flush_one()
+{
+    store_base* store;
+    {
+        std::lock_guard<std::mutex> lock(m_);
+        if(flushing_.empty())
+            return false;
+        store = flushing_.head_;
+        store->state_ = store_base::state::intermediate;
+        flushing_.erase(store);
+    }
+
+    store->flush();
+
+    std::lock_guard<std::mutex> lock(m_);
+    store->state_ = store_base::state::waiting;
+    waiting_.push_back(store);
+    cv_w_.notify_all();
+    return true;
+}
+
+void
+context::list::
+push_back(store_base* node)
+{
+    node->next_ = nullptr;
+    node->prev_ = tail_;
+    if(tail_)
+        tail_->next_ = node;
+    tail_ = node;
+    if(!head_)
+        head_ = node;
+}
+
+void
+context::list::
+erase(store_base* node)
+{
+    if(node->next_)
+        node->next_->prev_ = node->prev_;
+    else // node == tail_
+        tail_ = node->prev_;
+
+    if(node->prev_)
+        node->prev_->next_ = node->next_;
+    else // node == head_
+        head_ = node->next_;
+
+    node->next_ = nullptr;
+    node->prev_ = nullptr;
+}
+
+void
+context::list::
+splice(list& right)
+{
+    if(right.empty())
+        return;
+    if(empty())
+    {
+        head_ = right.head_;
+        tail_ = right.tail_;
+    }
+    else
+    {
+        right.head_->prev_ = tail_;
+        tail_->next_ = right.head_;
+        tail_ = right.tail_;
+    }
+    right.head_ = nullptr;
+    right.tail_ = nullptr;
+}
+
+} // nudb
+
+#endif

data/ext/rudb/NuDB/include/nudb/impl/create.ipp

@@ -0,0 +1,163 @@
+//
+// Copyright (c) 2015-2016 Vinnie Falco (vinnie dot falco at gmail dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef NUDB_IMPL_CREATE_IPP
+#define NUDB_IMPL_CREATE_IPP
+
+#include <nudb/concepts.hpp>
+#include <nudb/native_file.hpp>
+#include <nudb/detail/bucket.hpp>
+#include <nudb/detail/format.hpp>
+#include <algorithm>
+#include <cstring>
+#include <random>
+#include <stdexcept>
+#include <utility>
+
+namespace nudb {
+
+namespace detail {
+
+template<class = void>
+std::uint64_t
+make_uid()
+{
+    std::random_device rng;
+    std::mt19937_64 gen {rng()};
+    std::uniform_int_distribution <std::size_t> dist;
+    return dist(gen);
+}
+
+} // detail
+
+template<class>
+std::uint64_t
+make_salt()
+{
+    std::random_device rng;
+    std::mt19937_64 gen {rng()};
+    std::uniform_int_distribution <std::size_t> dist;
+    return dist(gen);
+}
+
+template<
+    class Hasher,
+    class File,
+    class... Args
+>
+void
+create(
+    path_type const& dat_path,
+    path_type const& key_path,
+    path_type const& log_path,
+    std::uint64_t appnum,
+    std::uint64_t salt,
+    nsize_t key_size,
+    nsize_t blockSize,
+    float load_factor,
+    error_code& ec,
+    Args&&... args)
+{
+    static_assert(is_File<File>::value,
+        "File requirements not met");
+
+    using namespace detail;
+    if(key_size < 1)
+    {
+        ec = error::invalid_key_size;
+        return;
+    }
+    if(blockSize > field<std::uint16_t>::max)
+    {
+        ec = error::invalid_block_size;
+        return;
+    }
+    if(load_factor <= 0.f || load_factor >= 1.f)
+    {
+        ec = error::invalid_load_factor;
+        return;
+    }
+    auto const capacity =
+        bucket_capacity(blockSize);
+    if(capacity < 1)
+    {
+        ec = error::invalid_block_size;
+        return;
+    }
+    bool edf = false;
+    bool ekf = false;
+    bool elf = false;
+    {
+        File df(args...);
+        File kf(args...);
+        File lf(args...);
+        df.create(file_mode::append, dat_path, ec);
+        if(ec)
+            goto fail;
+        edf = true;
+        kf.create(file_mode::append, key_path, ec);
+        if(ec)
+            goto fail;
+        ekf = true;
+        lf.create(file_mode::append, log_path, ec);
+        if(ec)
+            goto fail;
+        elf = true;
+        dat_file_header dh;
+        dh.version = currentVersion;
+        dh.uid = make_uid();
+        dh.appnum = appnum;
+        dh.key_size = key_size;
+
+        key_file_header kh;
+        kh.version = currentVersion;
+        kh.uid = dh.uid;
+        kh.appnum = appnum;
+        kh.key_size = key_size;
+        kh.salt = salt;
+        kh.pepper = pepper<Hasher>(salt);
+        kh.block_size = blockSize;
+        kh.load_factor = std::min<std::size_t>(
+            static_cast<std::size_t>(
+                65536.0 * load_factor), 65535);
+        write(df, dh, ec);
+        if(ec)
+            goto fail;
+        write(kf, kh, ec);
+        if(ec)
+            goto fail;
+        buffer buf{blockSize};
+        std::memset(buf.get(), 0, blockSize);
+        bucket b(blockSize, buf.get(), empty);
+        b.write(kf, blockSize, ec);
+        if(ec)
+            goto fail;
+        // VFALCO Leave log file empty?
+        df.sync(ec);
+        if(ec)
+            goto fail;
+        kf.sync(ec);
+        if(ec)
+            goto fail;
+        lf.sync(ec);
+        if(ec)
+            goto fail;
+        // Success
+        return;
+    }
+fail:
+    if(edf)
+        erase_file(dat_path);
+    if(ekf)
+        erase_file(key_path);
+    if(elf)
+        erase_file(log_path);
+}
+
+} // nudb
+
+#endif

data/ext/rudb/NuDB/include/nudb/impl/error.ipp

@@ -0,0 +1,175 @@
+//
+// Copyright (c) 2015-2016 Vinnie Falco (vinnie dot falco at gmail dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef NUDB_IMPL_ERROR_IPP
+#define NUDB_IMPL_ERROR_IPP
+
+namespace nudb {
+
+inline
+error_category const&
+nudb_category()
+{
+    struct cat_t : public error_category
+    {
+        char const*
+        name() const noexcept override
+        {
+            return "nudb";
+        }
+
+        std::string
+        message(int ev) const override
+        {
+            switch(static_cast<error>(ev))
+            {
+            default:
+            case error::key_not_found:
+                return "key not found";
+
+            case error::key_exists:
+                return "key already exists";
+
+            case error::short_read:
+                return "short read";
+
+            case error::log_file_exists:
+                return "a log file exists";
+
+            case error::no_key_file:
+                return "no key file";
+
+            case error::too_many_buckets:
+                return "too many buckets";
+
+            case error::not_data_file:
+                return "not a data file";
+
+            case error::not_key_file:
+                return "not a key file";
+
+            case error::not_log_file:
+                return "not a log file";
+
+            case error::different_version:
+                return "different version";
+
+            case error::invalid_key_size:
+                return "invalid key size";
+            
+            case error::invalid_block_size:
+                return "invalid block size";
+
+            case error::short_key_file:
+                return "short key file";
+
+            case error::short_bucket:
+                return "short bucket";
+
+            case error::short_spill:
+                return "short spill";
+
+            case error::short_data_record:
+                return "short data record";
+
+            case error::short_value:
+                return "short value";
+
+            case error::hash_mismatch:
+                return "hash mismatch";
+
+            case error::invalid_load_factor:
+                return "invalid load factor";
+
+            case error::invalid_capacity:
+                return "invalid capacity";
+
+            case error::invalid_bucket_count:
+                return "invalid bucket count";
+
+            case error::invalid_bucket_size:
+                return "invalid_bucket_size";
+
+            case error::incomplete_data_file_header:
+                return "incomplete data file header";
+
+            case error::incomplete_key_file_header:
+                return "incomplete key file header";
+
+            case error::invalid_log_record:
+                return "invalid log record";
+
+            case error::invalid_log_spill:
+                return "invalid spill in log";
+
+            case error::invalid_log_offset:
+                return "invalid offset in log";
+                
+            case error::invalid_log_index:
+                return "invalid index in log";
+
+            case error::invalid_spill_size:
+                return "invalid size in spill";
+
+            case error::uid_mismatch:
+                return "uid mismatch";
+
+            case error::appnum_mismatch:
+                return "appnum mismatch";
+
+            case error::key_size_mismatch:
+                return "key size mismatch";
+
+            case error::salt_mismatch:
+                return "salt mismatch";
+
+            case error::pepper_mismatch:
+                return "pepper mismatch";
+
+            case error::block_size_mismatch:
+                return "block size mismatch";
+
+            case error::orphaned_value:
+                return "orphaned value";
+
+            case error::missing_value:
+                return "missing value";
+
+            case error::size_mismatch:
+                return "size mismatch";
+
+            case error::duplicate_value:
+                return "duplicate value";
+            }
+        }
+
+        error_condition
+        default_error_condition(int ev) const noexcept override
+        {
+            return error_condition{ev, *this};
+        }
+
+        bool
+        equivalent(int ev,
+            error_condition const& ec) const noexcept override
+        {
+            return ec.value() == ev && &ec.category() == this;
+        }
+
+        bool
+        equivalent(error_code const& ec, int ev) const noexcept override
+        {
+            return ec.value() == ev && &ec.category() == this;
+        }
+    };
+    static cat_t const cat{};
+    return cat;
+}
+
+} // nudb
+
+#endif