Reimplement chainbase using intrusive instead of multi_index

CMakeLists.txt

@@ -21,9 +21,9 @@ FIND_PACKAGE(Boost 1.57 REQUIRED COMPONENTS filesystem unit_test_framework)
 SET(PLATFORM_LIBRARIES)
 
 if(CMAKE_CXX_STANDARD EQUAL 98)
-   message(FATAL_ERROR "chainbase requires c++14 or newer")
+   message(FATAL_ERROR "chainbase requires c++17 or newer")
 elseif(NOT CMAKE_CXX_STANDARD)
-   set(CMAKE_CXX_STANDARD 14)
+   set(CMAKE_CXX_STANDARD 17)
    set(CMAKE_CXX_STANDARD_REQUIRED ON)
 endif()
 

README.md

@@ -15,7 +15,7 @@
 
 ## Dependencies
 
-  - C++14
+  - C++17
   - [Boost](http://www.boost.org/)
   - CMake Build Process
   - Supports Linux, Mac OS X  (no Windows Support)

include/chainbase/chainbase_node_allocator.hpp

@@ -0,0 +1,65 @@
+#pragma once
+
+#include <cstddef>
+#include <boost/interprocess/offset_ptr.hpp>
+
+#include <chainbase/pinnable_mapped_file.hpp>
+
+namespace chainbase {
+
+   namespace bip = boost::interprocess;
+
+   template<typename T, typename S>
+   class chainbase_node_allocator {
+    public:
+      using value_type = T;
+      using pointer = bip::offset_ptr<T>;
+      using segment_manager = pinnable_mapped_file::segment_manager;
+      chainbase_node_allocator(segment_manager* manager) : _manager{manager} {}
+      chainbase_node_allocator(const chainbase_node_allocator& other) : _manager(other._manager) {}
+      template<typename U>
+      chainbase_node_allocator(const chainbase_node_allocator<U, S>& other) : _manager(other._manager) {}
+      pointer allocate(std::size_t num) {
+         if (num == 1) {
+            if (_freelist == nullptr) {
+               get_some();
+            }
+            list_item* result = &*_freelist;
+            _freelist = _freelist->_next;
+            result->~list_item();
+            return pointer{(T*)result};
+         } else {
+            return pointer{(T*)_manager->allocate(num*sizeof(T))};
+         }
+      }
+      void deallocate(const pointer& p, std::size_t num) {
+         if (num == 1) {
+            _freelist = new (&*p) list_item{_freelist};
+         } else {
+            _manager->deallocate(&*p);
+         }
+      }
+      bool operator==(const chainbase_node_allocator& other) const { return this == &other; }
+      bool operator!=(const chainbase_node_allocator& other) const { return this != &other; }
+      segment_manager* get_segment_manager() const { return _manager.get(); }
+    private:
+      template<typename T2, typename S2>
+      friend class chainbase_node_allocator;
+      void get_some() {
+         static_assert(sizeof(T) >= sizeof(list_item), "Too small for free list");
+         static_assert(sizeof(T) % alignof(list_item) == 0, "Bad alignment for free list");
+         char* result = (char*)_manager->allocate(sizeof(T) * 64);
+         _freelist = bip::offset_ptr<list_item>{(list_item*)result};
+         for(int i = 0; i < 63; ++i) {
+            char* next = result + sizeof(T);
+            new(result) list_item{bip::offset_ptr<list_item>{(list_item*)next}};
+            result = next;
+         }
+         new(result) list_item{nullptr};
+      }
+      struct list_item { bip::offset_ptr<list_item> _next; };
+      bip::offset_ptr<pinnable_mapped_file::segment_manager> _manager;
+      bip::offset_ptr<list_item> _freelist{};
+   };
+
+}  // namepsace chainbase

include/chainbase/shared_cow_string.hpp

@@ -0,0 +1,143 @@
+#pragma once
+
+#include <boost/container/container_fwd.hpp>
+#include <boost/interprocess/offset_ptr.hpp>
+#include <boost/interprocess/allocators/allocator.hpp>
+
+#include <cstddef>
+#include <cstring>
+#include <algorithm>
+#include <string>
+
+#include <chainbase/pinnable_mapped_file.hpp>
+
+namespace chainbase {
+
+   namespace bip = boost::interprocess;
+
+   class shared_cow_string {
+      struct impl {
+         uint32_t reference_count;
+         uint32_t size;
+         char data[0];
+      };
+    public:
+      using allocator_type = bip::allocator<char, pinnable_mapped_file::segment_manager>;
+      using iterator = const char*;
+      using const_iterator = const char*;
+      explicit shared_cow_string(const allocator_type& alloc) : _data(nullptr), _alloc(alloc) {}
+      template<typename Iter>
+      explicit shared_cow_string(Iter begin, Iter end, const allocator_type& alloc) : shared_cow_string(alloc) {
+         std::size_t size = std::distance(begin, end);
+         impl* new_data = (impl*)&*_alloc.allocate(sizeof(impl) + size + 1);
+         new_data->reference_count = 1;
+         new_data->size = size;
+         std::copy(begin, end, new_data->data);
+         new_data->data[size] = '\0';
+         _data = new_data;
+      }
+      explicit shared_cow_string(const char* ptr, std::size_t size, const allocator_type& alloc) : shared_cow_string(alloc) {
+         impl* new_data = (impl*)&*_alloc.allocate(sizeof(impl) + size + 1);
+         new_data->reference_count = 1;
+         new_data->size = size;
+         std::memcpy(new_data->data, ptr, size);
+         new_data->data[size] = '\0';
+         _data = new_data;
+      }
+      explicit shared_cow_string(std::size_t size, boost::container::default_init_t, const allocator_type& alloc) : shared_cow_string(alloc) {
+         impl* new_data = (impl*)&*_alloc.allocate(sizeof(impl) + size + 1);
+         new_data->reference_count = 1;
+         new_data->size = size;
+         new_data->data[size] = '\0';
+         _data = new_data;
+      }
+      shared_cow_string(const shared_cow_string& other) : _data(other._data), _alloc(other._alloc) {
+         if(_data != nullptr) {
+            ++_data->reference_count;
+         }
+      }
+      shared_cow_string(shared_cow_string&& other) : _data(other._data), _alloc(other._alloc) {
+         other._data = nullptr;
+      }
+      shared_cow_string& operator=(const shared_cow_string& other) {
+         *this = shared_cow_string{other};
+         return *this;
+      }
+      shared_cow_string& operator=(shared_cow_string&& other) {
+         if (this != &other) {
+            dec_refcount();
+            _data = other._data;
+            other._data = nullptr;
+         }
+         return *this;
+      }
+      ~shared_cow_string() {
+         dec_refcount();
+      }
+      void resize(std::size_t new_size, boost::container::default_init_t) {
+         impl* new_data = (impl*)&*_alloc.allocate(sizeof(impl) + new_size + 1);
+         new_data->reference_count = 1;
+         new_data->size = new_size;
+         new_data->data[new_size] = '\0';
+         dec_refcount();
+         _data = new_data;
+      }
+      template<typename F>
+      void resize_and_fill(std::size_t new_size, F&& f) {
+         resize(new_size, boost::container::default_init);
+         static_cast<F&&>(f)(_data->data, new_size);
+      }
+      void assign(const char* ptr, std::size_t size) {
+         impl* new_data = (impl*)&*_alloc.allocate(sizeof(impl) + size + 1);
+         new_data->reference_count = 1;
+         new_data->size = size;
+         if(size)
+            std::memcpy(new_data->data, ptr, size);
+         new_data->data[size] = '\0';
+         dec_refcount();
+         _data = new_data;
+      }
+      void assign(const unsigned char* ptr, std::size_t size) {
+         assign((char*)ptr, size);
+      }
+      const char * data() const {
+         if (_data) return _data->data;
+         else return nullptr;
+      }
+      std::size_t size() const {
+         if (_data) return _data->size;
+         else return 0;
+      }
+      const_iterator begin() const { return data(); }
+      const_iterator end() const {
+         if (_data) return _data->data + _data->size;
+         else return nullptr;
+      }
+      int compare(std::size_t start, std::size_t count, const char* other, std::size_t other_size) const {
+         std::size_t sz = size();
+         if(start > sz) BOOST_THROW_EXCEPTION(std::out_of_range{"shared_cow_string::compare"});
+         count = std::min(count, sz - start);
+         std::size_t cmp_len = std::min(count, other_size);
+         const char* start_ptr = data() + start;
+         int result = std::char_traits<char>::compare(start_ptr, other, cmp_len);
+         if (result != 0) return result;
+         else if (count < other_size) return -1;
+         else if(count > other_size) return 1;
+         else return 0;
+      }
+      bool operator==(const shared_cow_string& rhs) const {
+        return size() == rhs.size() && std::memcmp(data(), rhs.data(), size()) == 0;
+      }
+      bool operator!=(const shared_cow_string& rhs) const { return !(*this == rhs); }
+      const allocator_type& get_allocator() const { return _alloc; }
+    private:
+      void dec_refcount() {
+         if(_data && --_data->reference_count == 0) {
+            _alloc.deallocate((char*)&*_data, sizeof(shared_cow_string) + _data->size + 1);
+         }
+      }
+      bip::offset_ptr<impl> _data;
+      allocator_type _alloc;
+   };
+
+}  // namepsace chainbase