rrudb 0.0.2

data/ext/rudb/NuDB/include/nudb/context.hpp

@@ -0,0 +1,144 @@
+//
+// 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_CONTEXT_HPP
+#define NUDB_CONTEXT_HPP
+
+#include <condition_variable>
+#include <memory>
+#include <mutex>
+#include <thread>
+
+#define NUDB_DECL inline
+
+namespace nudb {
+
+namespace test {
+    class context_test;
+} // test
+
+namespace detail {
+    class store_base;
+} // detail
+
+class context
+{
+public:
+    /// Constructor
+    context() = default;
+
+    /** Destructor.
+
+        Halts execution of all threads. Blocks until all threads
+        have completed any ongoing operation and have stopped.
+    */
+    NUDB_DECL
+    ~context() noexcept (false);
+
+    /// Copy constructor (disallowed)
+    context(context const&) = delete;
+
+    /// Move constructor (disallowed)
+    context(context&&) = delete;
+
+    // Copy assignment (disallowed)
+    context& operator=(context const&) = delete;
+
+    // Move assignment (disallowed)
+    context& operator=(context&&) = delete;
+
+    /** Start thread execution.
+
+        Starts the context thread execution.
+    */
+    NUDB_DECL
+    void
+    start();
+
+    /** Stop thread execution.
+
+        Halts execution of all threads. Blocks until all threads
+        have completed any ongoing operation and have stopped.
+    */
+    NUDB_DECL
+    void
+    stop_all();
+
+    /** Thread function.
+
+        Function to service the databases.
+        Thread objects must call this function.
+    */
+    NUDB_DECL
+    void
+    run();
+
+private:
+    using clock_type = std::chrono::steady_clock;
+    using store_base = detail::store_base;
+
+    template<class, class> friend class basic_store;
+#if ! NUDB_DOXYGEN
+    friend class test::context_test;
+#endif
+
+    NUDB_DECL
+    void
+    insert(store_base& store);
+
+    NUDB_DECL
+    void
+    erase(store_base& store);
+
+    NUDB_DECL
+    bool
+    flush_one();
+
+    class list
+    {
+    public:
+        NUDB_DECL
+        void
+        push_back(store_base* node);
+
+        NUDB_DECL
+        void
+        erase(store_base* node);
+
+        NUDB_DECL
+        void
+        splice(list& l);
+
+        bool
+        empty() const noexcept
+        {
+            return head_ == nullptr;
+        }
+
+        store_base* head_ = nullptr;
+
+    private:
+        store_base* tail_ = nullptr;
+    };
+
+    std::mutex m_;
+    list waiting_;
+    std::condition_variable cv_w_;
+    list flushing_;
+    std::condition_variable cv_f_;
+
+    std::uint32_t num_threads_ = 0;
+    std::thread t_;
+
+    bool stop_ = false;
+};
+
+} // nudb
+
+#include <nudb/impl/context.ipp>
+
+#endif

data/ext/rudb/NuDB/include/nudb/create.hpp

@@ -0,0 +1,117 @@
+//
+// 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_CREATE_HPP
+#define NUDB_CREATE_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 {
+
+/** Return a random salt.
+
+    This function will use the system provided random
+    number device to generate a uniformly distributed
+    64-bit unsigned value suitable for use the salt
+    value in a call to @ref create.
+*/
+template<class = void>
+std::uint64_t
+make_salt();
+
+/** Create a new database.
+
+    This function creates a set of new database files with
+    the given parameters. The files must not already exist or
+    else an error is returned.
+
+    If an error occurs while the files are being created,
+    the function attempts to remove the files before
+    returning.
+
+    @par Example
+    @code
+        error_code ec;
+        create<xxhasher>(
+            "db.dat", "db.key", "db.log",
+                1, make_salt(), 8, 4096, 0.5f, ec);
+    @endcode
+
+    @par Template Parameters
+
+    @tparam Hasher The hash function to use. This type must
+    meet the requirements of @b Hasher. The same hash
+    function must be used every time the database is opened,
+    or else an error is returned. The provided @ref xxhasher
+    is a suitable general purpose hash function.
+
+    @tparam File The type of file to use. Use the default of
+    @ref native_file unless customizing the file behavior.
+
+    @param dat_path The path to the data file.
+
+    @param key_path The path to the key file.
+
+    @param log_path The path to the log file.
+
+    @param appnum A caller-defined value stored in the file
+    headers. When opening the database, the same value is
+    preserved and returned to the caller.
+
+    @param salt A random unsigned integer used to permute
+    the hash function to make it unpredictable. The return
+    value of @ref make_salt returns a suitable value.
+
+    @param key_size The number of bytes in each key.
+
+    @param blockSize The size of a key file block. Larger
+    blocks hold more keys but require more I/O cycles per
+    operation. The ideal block size the largest size that
+    may be read in a single I/O cycle, and device dependent.
+    The return value of @ref block_size returns a suitable
+    value for the volume of a given path.
+    
+    @param load_factor A number between zero and one
+    representing the average bucket occupancy (number of
+    items). A value of 0.5 is perfect. Lower numbers
+    waste space, and higher numbers produce negligible
+    savings at the cost of increased I/O cycles.
+
+    @param ec Set to the error, if any occurred.
+
+    @param args Optional arguments passed to @b File constructors.
+*/
+template<
+    class Hasher,
+    class File = native_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);
+
+} // nudb
+
+#include <nudb/impl/create.ipp>
+
+#endif

data/ext/rudb/NuDB/include/nudb/detail/arena.hpp

@@ -0,0 +1,296 @@
+//
+// 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_DETAIL_ARENA_HPP
+#define NUDB_DETAIL_ARENA_HPP
+
+#include <boost/assert.hpp>
+#include <algorithm>
+#include <chrono>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+
+#if NUDB_DEBUG_ARENA
+#include <boost/beast/_experimental/unit_test/dstream.hpp>
+#include <iostream>
+#endif
+
+namespace nudb {
+namespace detail {
+
+/*  Custom memory manager that allocates in large blocks.
+
+    The implementation measures the rate of allocations in
+    bytes per second and tunes the large block size to fit
+    one second's worth of allocations.
+*/
+template<class = void>
+class arena_t
+{
+    using clock_type =
+        std::chrono::steady_clock;
+    
+    using time_point =
+        typename clock_type::time_point;
+
+    class element;
+
+    char const* label_;         // diagnostic
+    std::size_t alloc_ = 0;     // block size
+    std::size_t used_ = 0;      // bytes allocated
+    element* list_ = nullptr;   // list of blocks
+    time_point when_ = clock_type::now();
+
+public:
+    arena_t(arena_t const&) = delete;
+    arena_t& operator=(arena_t&&) = delete;
+    arena_t& operator=(arena_t const&) = delete;
+
+    ~arena_t();
+
+    explicit
+    arena_t(char const* label = "");
+
+    arena_t(arena_t&& other);
+
+    // Set the allocation size
+    void
+    hint(std::size_t alloc)
+    {
+        alloc_ = alloc;
+    }
+
+    // Free all memory
+    void
+    clear();
+
+    void
+    periodic_activity();
+
+    std::uint8_t*
+    alloc(std::size_t n);
+
+    template<class U>
+    friend
+    void
+    swap(arena_t<U>& lhs, arena_t<U>& rhs);
+};
+
+//------------------------------------------------------------------------------
+
+template<class _>
+class arena_t<_>::element
+{
+    std::size_t const capacity_;
+    std::size_t used_ = 0;
+    element* next_;
+
+public:
+    element(std::size_t capacity, element* next)
+        : capacity_(capacity)
+        , next_(next)
+    {
+    }
+
+    element*
+    next() const
+    {
+        return next_;
+    }
+
+    void
+    clear()
+    {
+        used_ = 0;
+    }
+
+    std::size_t
+    remain() const
+    {
+        return capacity_ - used_;
+    }
+
+    std::size_t
+    capacity() const
+    {
+        return capacity_;
+    }
+
+    std::uint8_t*
+    alloc(std::size_t n);
+};
+
+template<class _>
+std::uint8_t*
+arena_t<_>::element::
+alloc(std::size_t n)
+{
+    if(n > capacity_ - used_)
+        return nullptr;
+    auto const p = const_cast<std::uint8_t*>(
+        reinterpret_cast<uint8_t const*>(this + 1)
+            ) + used_;
+    used_ += n;
+    return p;
+}
+
+//------------------------------------------------------------------------------
+
+template<class _>
+arena_t<_>::
+arena_t(char const* label)
+    : label_(label)
+{
+}
+
+template<class _>
+arena_t<_>::
+~arena_t()
+{
+    clear();
+}
+
+template<class _>
+arena_t<_>::
+arena_t(arena_t&& other)
+    : label_(other.label_)
+    , alloc_(other.alloc_)
+    , used_(other.used_)
+    , list_(other.list_)
+    , when_(other.when_)
+{
+    other.used_ = 0;
+    other.list_ = nullptr;
+    other.when_ = clock_type::now();
+    other.alloc_ = 0;
+}
+
+template<class _>
+void
+arena_t<_>::
+clear()
+{
+    used_ = 0;
+    while(list_)
+    {
+        auto const e = list_;
+        list_ = list_->next();
+        e->~element();
+        delete[] reinterpret_cast<std::uint8_t*>(e);
+    }
+}
+
+template<class _>
+void
+arena_t<_>::
+periodic_activity()
+{
+    using namespace std::chrono;
+    auto const now = clock_type::now();
+    auto const elapsed = now - when_;
+    if(elapsed < milliseconds{500})
+        return;
+    when_ = now;
+    auto const rate = static_cast<std::size_t>(std::ceil(
+        used_ / duration_cast<duration<float>>(elapsed).count()));
+#if NUDB_DEBUG_ARENA
+    beast::unit_test::dstream dout{std::cout};
+    auto const size =
+        [](element* e)
+        {
+            std::size_t n = 0;
+            while(e)
+            {
+                ++n;
+                e = e->next();
+            }
+            return n;
+        };
+#endif
+    if(rate >= alloc_ * 2)
+    {
+        // adjust up
+        alloc_ = std::max(rate, alloc_ * 2);
+    #if NUDB_DEBUG_ARENA
+        dout << label_ << ": "
+            "rate=" << rate <<
+            ", alloc=" << alloc_ << " UP"
+            ", nused=" << used_ <<
+            ", used=" << size(list_) <<
+            "\n";
+    #endif
+    }
+    else if(rate <= alloc_ / 2)
+    {
+        // adjust down
+        alloc_ /= 2;
+    #if NUDB_DEBUG_ARENA
+        dout << label_ << ": "
+            "rate=" << rate <<
+            ", alloc=" << alloc_ << " DOWN"
+            ", nused=" << used_ <<
+            ", used=" << size(list_) <<
+            "\n";
+    #endif
+    }
+    else
+    {
+    #if NUDB_DEBUG_ARENA
+        dout << label_ << ": "
+            "rate=" << rate <<
+            ", alloc=" << alloc_ <<
+            ", nused=" << used_ <<
+            ", used=" << size(list_) <<
+            "\n";
+    #endif
+    }
+}
+
+template<class _>
+std::uint8_t*
+arena_t<_>::
+alloc(std::size_t n)
+{
+    // Undefined behavior: Zero byte allocations
+    BOOST_ASSERT(n != 0);
+    n = 8 *((n + 7) / 8);
+    std::uint8_t* p;
+    if(list_)
+    {
+        p = list_->alloc(n);
+        if(p)
+        {
+            used_ += n;
+            return p;
+        }
+    }
+    auto const size = std::max(alloc_, n);
+    auto const e = reinterpret_cast<element*>(
+        new std::uint8_t[sizeof(element) + size]);
+    list_ = ::new(e) element{size, list_};
+    used_ += n;
+    return list_->alloc(n);
+}
+
+template<class _>
+void
+swap(arena_t<_>& lhs, arena_t<_>& rhs)
+{
+    using std::swap;
+    swap(lhs.used_, rhs.used_);
+    swap(lhs.list_, rhs.list_);
+    // don't swap alloc_ or when_
+}
+
+using arena = arena_t<>;
+
+} // detail
+} // nudb
+
+#endif