rrudb 0.0.2

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

@@ -0,0 +1,259 @@
+//
+// 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_GENTEX_HPP
+#define NUDB_DETAIL_GENTEX_HPP
+
+#include <boost/assert.hpp>
+#include <condition_variable>
+#include <cstddef>
+#include <mutex>
+#include <system_error>
+
+namespace nudb {
+namespace detail {
+
+//  Generation counting mutex
+//
+template<class = void>
+class gentex_t
+{
+private:
+    std::mutex m_;
+    std::size_t gen_ = 0;
+    std::size_t cur_ = 0;
+    std::size_t prev_ = 0;
+    std::condition_variable cond_;
+
+public:
+    gentex_t() = default;
+    gentex_t(gentex_t const&) = delete;
+    gentex_t& operator=(gentex_t const&) = delete;
+
+    void
+    start();
+
+    void
+    finish();
+
+    std::size_t
+    lock_gen();
+
+    void
+    unlock_gen(std::size_t gen);
+};
+
+template<class _>
+void
+gentex_t<_>::
+start()
+{
+    std::unique_lock<std::mutex> l{m_};
+    prev_ += cur_;
+    cur_ = 0;
+    ++gen_;
+}
+
+template<class _>
+void
+gentex_t<_>::
+finish()
+{
+    std::unique_lock<std::mutex> l{m_};
+    while(prev_ > 0)
+        cond_.wait(l);
+}
+
+template<class _>
+std::size_t
+gentex_t<_>::
+lock_gen()
+{
+    std::lock_guard<
+        std::mutex> l{m_};
+    ++cur_;
+    return gen_;
+}
+
+template<class _>
+void
+gentex_t<_>::
+unlock_gen(std::size_t gen)
+{
+    std::unique_lock<std::mutex> l{m_};
+    if(gen == gen_)
+    {
+        --cur_;
+    }
+    else
+    {
+        --prev_;
+        if(prev_ == 0)
+            cond_.notify_all();
+    }
+}
+
+using gentex = gentex_t<>;
+
+//------------------------------------------------------------------------------
+
+template<class GenerationLockable>
+class genlock
+{
+private:
+    bool owned_ = false;
+    GenerationLockable* g_ = nullptr;
+    std::size_t gen_;
+
+public:
+    using mutex_type = GenerationLockable;
+
+    genlock() = default;
+    genlock(genlock const&) = delete;
+    genlock& operator=(genlock const&) = delete;
+
+    genlock(genlock&& other);
+
+    genlock& operator=(genlock&& other);
+
+    explicit
+    genlock(mutex_type& g);
+
+    genlock(mutex_type& g, std::defer_lock_t);
+
+    ~genlock();
+
+    mutex_type*
+    mutex() noexcept
+    {
+        return g_;
+    }
+
+    bool
+    owns_lock() const noexcept
+    {
+        return g_ && owned_;
+    }
+
+    explicit
+    operator bool() const noexcept
+    {
+        return owns_lock();
+    }
+
+    void
+    lock();
+
+    void
+    unlock();
+
+    mutex_type*
+    release() noexcept;
+
+    template<class U>
+    friend
+    void
+    swap(genlock<U>& lhs, genlock<U>& rhs) noexcept;
+};
+
+template<class G>
+genlock<G>::
+genlock(genlock&& other)
+    : owned_(other.owned_)
+    , g_(other.g_)
+{
+    other.owned_ = false;
+    other.g_ = nullptr;
+}
+
+template<class G>
+genlock<G>&
+genlock<G>::
+operator=(genlock&& other)
+{
+    if(owns_lock())
+        unlock();
+    owned_ = other.owned_;
+    g_ = other.g_;
+    other.owned_ = false;
+    other.g_ = nullptr;
+    return *this;
+}
+
+template<class G>
+genlock<G>::
+genlock(mutex_type& g)
+    : g_(&g)
+{
+    lock();
+}
+
+template<class G>
+genlock<G>::
+genlock(mutex_type& g, std::defer_lock_t)
+    : g_(&g)
+{
+}
+
+template<class G>
+genlock<G>::
+~genlock()
+{
+    if(owns_lock())
+        unlock();
+}
+
+template<class G>
+void
+genlock<G>::
+lock()
+{
+    // no associated gentex
+    BOOST_ASSERT(g_ != nullptr);
+    // gentex is already owned
+    BOOST_ASSERT(! owned_);
+    gen_ = g_->lock_gen();
+    owned_ = true;
+}
+
+template<class G>
+void
+genlock<G>::
+unlock()
+{
+    // no associated gentex
+    BOOST_ASSERT(g_ != nullptr);
+    // gentex is not owned
+    BOOST_ASSERT(owned_);
+    g_->unlock_gen(gen_);
+    owned_ = false;
+}
+
+template<class G>
+auto
+genlock<G>::
+release() noexcept ->
+    mutex_type*
+{
+    mutex_type* const g = g_;
+    g_ = nullptr;
+    return g;
+}
+
+template<class G>
+void
+swap(genlock<G>& lhs, genlock<G>& rhs) noexcept
+{
+    using namespace std;
+    swap(lhs.owned_, rhs.owned_);
+    swap(lhs.g_, rhs.g_);
+}
+
+} // detail
+} // nudb
+
+#endif

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

@@ -0,0 +1,26 @@
+//
+// 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_MUTEX_HPP
+#define NUDB_DETAIL_MUTEX_HPP
+
+#include <boost/thread/lock_types.hpp>
+#include <boost/thread/shared_mutex.hpp>
+
+namespace nudb {
+namespace detail {
+
+using shared_lock_type =
+    boost::shared_lock<boost::shared_mutex>;
+
+using unique_lock_type =
+    boost::unique_lock<boost::shared_mutex>;
+
+} // detail
+} // nudb
+
+#endif

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

@@ -0,0 +1,243 @@
+//
+// 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_POOL_HPP
+#define NUDB_DETAIL_POOL_HPP
+
+#include <nudb/detail/arena.hpp>
+#include <nudb/detail/bucket.hpp>
+#include <nudb/detail/format.hpp>
+#include <boost/assert.hpp>
+#include <boost/thread/lock_types.hpp>
+#include <cstdint>
+#include <cstring>
+#include <memory>
+#include <map>
+#include <utility>
+
+namespace nudb {
+namespace detail {
+
+// Buffers key/value pairs in a map, associating
+// them with a modifiable data file offset.
+template<class = void>
+class pool_t
+{
+public:
+    struct value_type;
+    class compare;
+
+private:
+    using map_type = std::map<
+        value_type, noff_t, compare>;
+
+    arena arena_;
+    nsize_t key_size_;
+    nsize_t data_size_ = 0;
+    map_type map_;
+
+public:
+    using iterator =
+        typename map_type::iterator;
+
+    pool_t(pool_t const&) = delete;
+    pool_t& operator=(pool_t const&) = delete;
+
+    pool_t(pool_t&& other);
+
+    pool_t(nsize_t key_size, char const* label);
+
+    iterator
+    begin()
+    {
+        return map_.begin();
+    }
+
+    iterator
+    end()
+    {
+        return map_.end();
+    }
+
+    bool
+    empty() const
+    {
+        return map_.size() == 0;
+    }
+
+    // Returns the number of elements in the pool
+    std::size_t
+    size() const
+    {
+        return map_.size();
+    }
+
+    // Returns the sum of data sizes in the pool
+    std::size_t
+    data_size() const
+    {
+        return data_size_;
+    }
+
+    void
+    clear();
+
+    void
+    periodic_activity();
+
+    iterator
+    find(void const* key);
+
+    // Insert a value
+    // @param h The hash of the key
+    void
+    insert(nhash_t h, void const* key,
+        void const* buffer, nsize_t size);
+
+    template<class U>
+    friend
+    void
+    swap(pool_t<U>& lhs, pool_t<U>& rhs);
+};
+
+template<class _>
+struct pool_t<_>::value_type
+{
+    nhash_t hash;
+    nsize_t size;
+    void const* key;
+    void const* data;
+
+    value_type(value_type const&) = default;
+    value_type& operator=(value_type const&) = default;
+
+    value_type(nhash_t hash_, nsize_t size_,
+            void const* key_, void const* data_)
+        : hash(hash_)
+        , size(size_)
+        , key(key_)
+        , data(data_)
+    {
+    }
+};
+
+template<class _>
+class pool_t<_>::compare
+{
+    std::size_t key_size_;
+
+public:
+    using result_type = bool;
+    using first_argument_type = value_type;
+    using second_argument_type = value_type;
+
+    compare(compare const&) = default;
+    compare& operator=(compare const&) = default;
+
+    explicit
+    compare(nsize_t key_size)
+        : key_size_(key_size)
+    {
+    }
+
+    bool
+    operator()(value_type const& lhs,
+        value_type const& rhs) const
+    {
+        return std::memcmp(
+            lhs.key, rhs.key, key_size_) < 0;
+    }
+};
+
+//------------------------------------------------------------------------------
+
+template<class _>
+pool_t<_>::
+pool_t(pool_t&& other)
+    : arena_(std::move(other.arena_))
+    , key_size_(other.key_size_)
+    , data_size_(other.data_size_)
+    , map_(std::move(other.map_))
+{
+}
+
+template<class _>
+pool_t<_>::
+pool_t(nsize_t key_size, char const* label)
+    : arena_(label)
+    , key_size_(key_size)
+    , map_(compare{key_size})
+{
+}
+
+template<class _>
+void
+pool_t<_>::
+clear()
+{
+    arena_.clear();
+    data_size_ = 0;
+    map_.clear();
+}
+
+template<class _>
+void
+pool_t<_>::
+periodic_activity()
+{
+    arena_.periodic_activity();
+}
+
+template<class _>
+auto
+pool_t<_>::
+find(void const* key) ->
+    iterator
+{
+    // VFALCO need is_transparent here
+    value_type tmp{0, 0, key, nullptr};
+    auto const iter = map_.find(tmp);
+    return iter;
+}
+
+template<class _>
+void
+pool_t<_>::
+insert(nhash_t h,
+    void const* key, void const* data, nsize_t size)
+{
+    auto const k = arena_.alloc(key_size_);
+    auto const d = arena_.alloc(size);
+    std::memcpy(k, key, key_size_);
+    std::memcpy(d, data, size);
+    auto const result = map_.emplace(
+        std::piecewise_construct,
+            std::make_tuple(h, size, k, d),
+                std::make_tuple(0));
+   (void)result.second;
+    // Must not already exist!
+    BOOST_ASSERT(result.second);
+    data_size_ += size;
+}
+
+template<class _>
+void
+swap(pool_t<_>& lhs, pool_t<_>& rhs)
+{
+    using std::swap;
+    swap(lhs.arena_, rhs.arena_);
+    swap(lhs.key_size_, rhs.key_size_);
+    swap(lhs.data_size_, rhs.data_size_);
+    swap(lhs.map_, rhs.map_);
+}
+
+using pool = pool_t<>;
+
+} // detail
+} // nudb
+
+#endif

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

@@ -0,0 +1,45 @@
+//
+// 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_DETAIL_STORE_BASE_HPP
+#define NUDB_DETAIL_STORE_BASE_HPP
+
+namespace nudb {
+
+class context;
+
+namespace detail {
+
+class store_base
+{
+protected:
+    friend class nudb::context;
+
+    virtual void flush() = 0;
+
+private:
+#if ! NUDB_DOXYGEN
+    friend class test::context_test;
+#endif
+
+    enum class state
+    {
+        waiting,
+        flushing,
+        intermediate,
+        none
+    };
+
+    store_base* next_ = nullptr;
+    store_base* prev_ = nullptr;
+    state state_ = state::none;
+};
+
+} // detail
+} // nudb
+
+#endif

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

@@ -0,0 +1,149 @@
+//
+// 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_STREAM_HPP
+#define NUDB_DETAIL_STREAM_HPP
+
+#include <boost/assert.hpp>
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <memory>
+
+namespace nudb {
+namespace detail {
+
+// Input stream from bytes
+template<class = void>
+class istream_t
+{
+    std::uint8_t const* buf_ = nullptr;
+    std::size_t size_ = 0;
+
+public:
+    istream_t() = default;
+    istream_t(istream_t const&) = default;
+    istream_t& operator=(istream_t const&) = default;
+
+    istream_t(void const* data, std::size_t size)
+        : buf_(reinterpret_cast<std::uint8_t const*>(data))
+        , size_(size)
+    {
+    }
+
+    template<std::size_t N>
+    istream_t(std::array<std::uint8_t, N> const& a)
+        : buf_(a.data())
+        , size_(a.size())
+    {
+    }
+
+    std::uint8_t const*
+    data(std::size_t bytes);
+
+    std::uint8_t const*
+    operator()(std::size_t bytes)
+    {
+        return data(bytes);
+    }
+};
+
+// Precondition: bytes <= size_
+//
+template<class _>
+std::uint8_t const*
+istream_t<_>::data(std::size_t bytes)
+{
+    BOOST_ASSERT(bytes <= size_);
+    if(size_ < bytes)
+        throw std::logic_error("short read from istream");
+    auto const data = buf_;
+    buf_ = buf_ + bytes;
+    size_ -= bytes;
+    return data;
+}
+
+using istream = istream_t<>;
+
+//------------------------------------------------------------------------------
+
+// Output stream to bytes
+// VFALCO Should this assert on overwriting the buffer?
+template<class = void>
+class ostream_t
+{
+    std::uint8_t* buf_ = nullptr;
+    std::size_t size_ = 0;
+
+public:
+    ostream_t() = default;
+    ostream_t(ostream_t const&) = default;
+    ostream_t& operator=(ostream_t const&) = default;
+
+    ostream_t(void* data, std::size_t)
+        : buf_(reinterpret_cast<std::uint8_t*>(data))
+    {
+    }
+
+    template<std::size_t N>
+    ostream_t(std::array<std::uint8_t, N>& a)
+        : buf_(a.data())
+    {
+    }
+
+    // Returns the number of bytes written
+    std::size_t
+    size() const
+    {
+        return size_;
+    }
+
+    std::uint8_t*
+    data(std::size_t bytes);
+
+    std::uint8_t*
+    operator()(std::size_t bytes)
+    {
+        return data(bytes);
+    }
+};
+
+template<class _>
+std::uint8_t*
+ostream_t<_>::data(std::size_t bytes)
+{
+    auto const data = buf_;
+    buf_ = buf_ + bytes;
+    size_ += bytes;
+    return data;
+}
+
+using ostream = ostream_t<>;
+
+//------------------------------------------------------------------------------
+
+// read blob
+inline
+void
+read(istream& is, void* buffer, std::size_t bytes)
+{
+    std::memcpy(buffer, is.data(bytes), bytes);
+}
+
+// write blob
+inline
+void
+write(ostream& os, void const* buffer, std::size_t bytes)
+{
+    std::memcpy(os.data(bytes), buffer, bytes);
+}
+
+} // detail
+} // nudb
+
+#endif