From b62ccc5d017e54beecd72d64d2074473c49192a7 Mon Sep 17 00:00:00 2001 From: Boris Kolpackov Date: Thu, 4 Jan 2018 09:49:34 +0200 Subject: Implement small_list, small_forward_list Note that with VC small_list is never "small" because of the extra "headnode" that this implementation allocates (see notes in small-list.mxx for details). --- libbutl/small-allocator.mxx | 196 +++++++++++++++++++++++++++++++++++++++++ libbutl/small-forward-list.mxx | 158 +++++++++++++++++++++++++++++++++ libbutl/small-list.mxx | 163 ++++++++++++++++++++++++++++++++++ libbutl/small-vector.mxx | 147 +++---------------------------- 4 files changed, 527 insertions(+), 137 deletions(-) create mode 100644 libbutl/small-allocator.mxx create mode 100644 libbutl/small-forward-list.mxx create mode 100644 libbutl/small-list.mxx (limited to 'libbutl') diff --git a/libbutl/small-allocator.mxx b/libbutl/small-allocator.mxx new file mode 100644 index 0000000..2c61e1c --- /dev/null +++ b/libbutl/small-allocator.mxx @@ -0,0 +1,196 @@ +// file : libbutl/small-allocator.mxx -*- C++ -*- +// copyright : Copyright (c) 2014-2017 Code Synthesis Ltd +// license : MIT; see accompanying LICENSE file + +#ifndef __cpp_modules +#pragma once +#endif + +#include + +#ifndef __cpp_lib_modules +#include // size_t +#include // move() +#include // true_type, is_same +#endif + +// Other includes. + +#ifdef __cpp_modules +export module butl.small_allocator; +#ifdef __cpp_lib_modules +import std.core; +#endif +#endif + +#include + +LIBBUTL_MODEXPORT namespace butl +{ + // Implementation of the allocator (and its buffer) for small containers. + // + template + struct small_allocator_buffer + { + using value_type = T; + + // Note that the names are decorated in order not to conflict with + // the container's interface. + + // If free_ is true then the buffer is not allocated. + // + alignas (alignof (value_type)) char data_[sizeof (value_type) * N]; + bool free_ = true; + + // Note that the buffer should be constructed before the container and + // destroyed after (since the container's destructor will be destroying + // elements potentially residing in the buffer). This means that the + // buffer should be inherited from and before the std:: container. + // + small_allocator_buffer () = default; + + small_allocator_buffer (small_allocator_buffer&&) = delete; + small_allocator_buffer (const small_allocator_buffer&) = delete; + + small_allocator_buffer& operator= (small_allocator_buffer&&) = delete; + small_allocator_buffer& operator= (const small_allocator_buffer&) = delete; + }; + + template > + class small_allocator + { + public: + using buffer_type = B; + + explicit + small_allocator (buffer_type* b) noexcept: buf_ (b) {} + + // Allocator interface. + // + public: + using value_type = T; + + // These shouldn't be required but as usual there are old/broken + // implementations (like std::list in GCC 4.9). + // + using pointer = value_type*; + using const_pointer = const value_type*; + using reference = value_type&; + using const_reference = const value_type&; + + static void destroy (T* p) {p->~T ();} + + template + static void construct (T* p, A&&... a) + { + ::new (static_cast (p)) T (std::forward (a)...); + } + + // Allocator rebinding. + // + // We assume that only one of the rebound allocators will actually be + // doing allocations and that its value type is the same as buffer value + // type. This is needed, for instance, for std::list since what actually + // gets allocated is the node type, not T (see small_list for details). + // + template + struct rebind {using other = small_allocator;}; + + template + explicit + small_allocator (const small_allocator& x) noexcept + : buf_ (x.buf_) {} + + T* + allocate (std::size_t n) + { + // An implementation can rebind the allocator to something completely + // different. For example, VC15u3 with _ITERATOR_DEBUG_LEVEL != 0 + // allocates some extra stuff which cannot possibly come from the static + // buffer. + // + if (std::is_same::value) + { + if (buf_->free_) + { + assert (n >= N); // We should never be asked for less than N. + + if (n == N) + { + buf_->free_ = false; + return reinterpret_cast (buf_->data_); + } + // Fall through. + } + } + + return static_cast (::operator new (sizeof (T) * n)); + } + + void + deallocate (void* p, std::size_t) noexcept + { + if (p == buf_->data_) + buf_->free_ = true; + else + ::operator delete (p); + } + + friend bool + operator== (small_allocator x, small_allocator y) noexcept + { + // We can use y to deallocate x's allocations if they use the same small + // buffer or neither uses its small buffer (which means all allocations, + // if any, have been from the shared heap). + // + // Things get trickier with rebinding. If A is allocator and B is its + // rebinding, then the following must hold true: + // + // A a1(a) => a1==a + // A a(b) => B(a)==b && A(b)==a + // + // As a result, the rebinding constructor above always copies the buffer + // pointer and we decide whether to use the small buffer by comparing + // allocator/buffer value types. + // + // We also expect that any copy of the original allocator made by the + // std:: implementation of the container is temporary (that is, it + // doesn't outlive the small buffer). + // + return (x.buf_ == y.buf_) || (x.buf_->free_ && y.buf_->free_); + } + + friend bool + operator!= (small_allocator x, small_allocator y) noexcept + { + return !(x == y); + } + + // It might get instantiated but should not be called. + // + small_allocator + select_on_container_copy_construction () const noexcept + { + assert (false); + return small_allocator (nullptr); + } + + // propagate_on_container_copy_assignment = false + // propagate_on_container_move_assignment = false + + // Swap is not supported (see explanation in small_vector::swap()). + // + using propagate_on_container_swap = std::true_type; + + void + swap (small_allocator&) = delete; + + private: + template + friend class small_allocator; // For buffer access in rebind. + + buffer_type* buf_; // Must not be NULL. + }; +} diff --git a/libbutl/small-forward-list.mxx b/libbutl/small-forward-list.mxx new file mode 100644 index 0000000..9411367 --- /dev/null +++ b/libbutl/small-forward-list.mxx @@ -0,0 +1,158 @@ +// file : libbutl/small-forward-list.mxx -*- C++ -*- +// copyright : Copyright (c) 2014-2017 Code Synthesis Ltd +// license : MIT; see accompanying LICENSE file + +#ifndef __cpp_modules +#pragma once +#endif + +#ifndef __cpp_lib_modules +#include // size_t +#include // move() +#include +#endif + +// Other includes. + +#ifdef __cpp_modules +export module butl.small_forward_list; +#ifdef __cpp_lib_modules +import std.core; +#endif +import butl.small_allocator; +#else +#include +#endif + +#include + +LIBBUTL_MODEXPORT namespace butl +{ + // Issues and limitations. + // + // - Because small_allocator currently expects us to allocate the entire + // small buffer and there is no reserve() in std::forward_list, we + // currently only support N==1 (which we static_assert). + // + // - swap() is deleted (see notes below). + // + // - The implementation doesn't allocate T but rather a "node" that normally + // consists of a pointers (next) and T. + // + template + using small_forward_list_node = +#if defined (_MSC_VER) + std::_Flist_node; +#elif defined (__GLIBCXX__) + std::_Fwd_list_node; +#elif defined (_LIBCPP_VERSION) + std::__forward_list_node; +#else +#error unknown standard library implementation +#endif + + template + using small_forward_list_buffer = + small_allocator_buffer, N>; + + template + class small_forward_list: + private small_forward_list_buffer, + public std::forward_list>> + { + static_assert (N == 1, "only small_forward_list or 1 currently supported"); + + public: + using buffer_type = small_forward_list_buffer; + using allocator_type = small_allocator; + using base_type = std::forward_list; + + small_forward_list () + : base_type (allocator_type (this)) {} + + small_forward_list (std::initializer_list v) + : base_type (allocator_type (this)) + { + static_cast (*this) = v; + } + + template + small_forward_list (I b, I e) + : base_type (allocator_type (this)) + { + this->assign (b, e); + } + + explicit + small_forward_list (std::size_t n) + : base_type (allocator_type (this)) + { + this->resize (n); + } + + small_forward_list (std::size_t n, const T& x) + : base_type (allocator_type (this)) + { + this->assign (n, x); + } + + small_forward_list (const small_forward_list& v) + : buffer_type (), base_type (allocator_type (this)) + { + static_cast (*this) = v; + } + + small_forward_list& + operator= (const small_forward_list& v) + { + // Note: propagate_on_container_copy_assignment = false + // + static_cast (*this) = v; + return *this; + } + + small_forward_list (small_forward_list&& v) + : base_type (allocator_type (this)) + { + *this = std::move (v); // Delegate to operator=(&&). + } + + small_forward_list& + operator= (small_forward_list&& v) + { + // VC14's implementation of operator=(&&) swaps pointers without regard + // for allocator (fixed in 15). + // +#if defined(_MSC_VER) && _MSC_VER <= 1900 + clear (); + for (T& x: v) + push_front (std::move (x)); + reverse (); + v.clear (); +#else + // Note: propagate_on_container_move_assignment = false + // + static_cast (*this) = std::move (v); +#endif + + return *this; + } + + small_forward_list& + operator= (std::initializer_list v) + { + static_cast (*this) = v; + return *this; + } + + // Implementing swap() under small buffer optimization is not trivial, to + // say the least (think of swapping two such buffers of different sizes). + // One easy option would be to force both in to the heap. + // + void + swap (small_forward_list&) = delete; + }; +} diff --git a/libbutl/small-list.mxx b/libbutl/small-list.mxx new file mode 100644 index 0000000..0f572a3 --- /dev/null +++ b/libbutl/small-list.mxx @@ -0,0 +1,163 @@ +// file : libbutl/small-list.mxx -*- C++ -*- +// copyright : Copyright (c) 2014-2017 Code Synthesis Ltd +// license : MIT; see accompanying LICENSE file + +#ifndef __cpp_modules +#pragma once +#endif + +#ifndef __cpp_lib_modules +#include +#include // size_t +#include // move() +#endif + +// Other includes. + +#ifdef __cpp_modules +export module butl.small_list; +#ifdef __cpp_lib_modules +import std.core; +#endif +import butl.small_allocator; +#else +#include +#endif + +#include + +LIBBUTL_MODEXPORT namespace butl +{ + // Issues and limitations. + // + // - VC's implementation of std::list allocates an extra "headnode" + // (something to do with additional iterator stability guarantees). Which + // means only empty small list will actually be "small". As a result, + // unless you don't care about VC, you should use small_forward_list + // instead. + // + // - Because small_allocator currently expects us to allocate the entire + // small buffer and there is no reserve() in std::list, we currently + // only support N==1 (which we static_assert). + // + // - swap() is deleted (see notes below). + // + // - The implementation doesn't allocate T but rather a "node" that normally + // consists of two pointers (prev/next) and T. + // + template + using small_list_node = +#if defined (_MSC_VER) + std::_List_node; +#elif defined (__GLIBCXX__) + std::_List_node; +#elif defined (_LIBCPP_VERSION) + std::__list_node; +#else +#error unknown standard library implementation +#endif + + template + using small_list_buffer = small_allocator_buffer, N>; + + template + class small_list: + private small_list_buffer, + public std::list>> + { + static_assert (N == 1, "only small_list or 1 currently supported"); + + public: + using buffer_type = small_list_buffer; + using allocator_type = small_allocator; + using base_type = std::list; + + small_list () + : base_type (allocator_type (this)) {} + + small_list (std::initializer_list v) + : base_type (allocator_type (this)) + { + static_cast (*this) = v; + } + + template + small_list (I b, I e) + : base_type (allocator_type (this)) + { + this->assign (b, e); + } + + explicit + small_list (std::size_t n) + : base_type (allocator_type (this)) + { + this->resize (n); + } + + small_list (std::size_t n, const T& x) + : base_type (allocator_type (this)) + { + this->assign (n, x); + } + + small_list (const small_list& v) + : buffer_type (), base_type (allocator_type (this)) + { + static_cast (*this) = v; + } + + small_list& + operator= (const small_list& v) + { + // Note: propagate_on_container_copy_assignment = false + // + static_cast (*this) = v; + return *this; + } + + small_list (small_list&& v) + : base_type (allocator_type (this)) + { + *this = std::move (v); // Delegate to operator=(&&). + } + + small_list& + operator= (small_list&& v) + { + // libstdc++'s implementation prior to GCC 6 is broken (calls swap()). + // Since there is no easy way to determine this library's version, for + // now this is always enabled. + // + // Similarly, VC14's implementation of operator=(&&) swaps pointers + // without regard for allocator (fixed in 15). + // +#if defined(__GLIBCXX__) || (defined(_MSC_VER) && _MSC_VER <= 1900) + this->clear (); + for (T& x: v) + this->push_back (std::move (x)); + v.clear (); +#else + // Note: propagate_on_container_move_assignment = false + // + static_cast (*this) = std::move (v); +#endif + + return *this; + } + + small_list& + operator= (std::initializer_list v) + { + static_cast (*this) = v; + return *this; + } + + // Implementing swap() under small buffer optimization is not trivial, to + // say the least (think of swapping two such buffers of different sizes). + // One easy option would be to force both in to the heap. + // + void + swap (small_list&) = delete; + }; +} diff --git a/libbutl/small-vector.mxx b/libbutl/small-vector.mxx index fb77935..7996f72 100644 --- a/libbutl/small-vector.mxx +++ b/libbutl/small-vector.mxx @@ -6,13 +6,10 @@ #pragma once #endif -#include - #ifndef __cpp_lib_modules #include #include // size_t -#include // move(), forward() -#include // true_type +#include // move() #endif // Other includes. @@ -22,139 +19,15 @@ export module butl.small_vector; #ifdef __cpp_lib_modules import std.core; #endif +import butl.small_allocator; +#else +#include #endif #include LIBBUTL_MODEXPORT namespace butl { - template - struct small_vector_buffer - { - // Size keeps track of the number of elements that are constructed in - // the buffer. Size equal N + 1 means the buffer is not allocated. - // - // Note that the names are decorated in order not to conflict with - // std::vector interface. - // - alignas (alignof (T)) char data_[sizeof (T) * N]; - bool free_ = true; - - // Note that the buffer should be constructed before std::vector and - // destroyed after (since std::vector's destructor will be destroying - // elements potentially residing in the buffer). This means that the - // buffer should be inherited from and before std::vector. - // - small_vector_buffer () = default; - - small_vector_buffer (small_vector_buffer&&) = delete; - small_vector_buffer (const small_vector_buffer&) = delete; - - small_vector_buffer& operator= (small_vector_buffer&&) = delete; - small_vector_buffer& operator= (const small_vector_buffer&) = delete; - }; - - template - class small_vector_allocator - { - public: - using buffer_type = small_vector_buffer; - - explicit - small_vector_allocator (buffer_type* b) noexcept: buf_ (b) {} - - // Required by VC15u3 when _ITERATOR_DEBUG_LEVEL is not 0. It allocates - // some extra stuff which cannot possibly come from the static buffer. - // -#if defined(_MSC_VER) && _MSC_VER >= 1911 - template - explicit - small_vector_allocator (const small_vector_allocator&) noexcept - : buf_ (nullptr) {} -#endif - - // Allocator interface. - // - public: - using value_type = T; - - T* - allocate(std::size_t n) - { - if (buf_ != nullptr) - { - assert (n >= N); // We should never be asked for less than N. - - if (n == N) - { - buf_->free_ = false; - return reinterpret_cast (buf_->data_); - } - // Fall through. - } - - return static_cast (::operator new (sizeof (T) * n)); - } - - void - deallocate (void* p, std::size_t) noexcept - { - if (buf_ != nullptr && p == buf_->data_) - buf_->free_ = true; - else - ::operator delete (p); - } - - friend bool - operator== (small_vector_allocator x, small_vector_allocator y) noexcept - { - // We can use y to deallocate x's allocations if they use the same small - // buffer or neither uses its small buffer (which means all allocations, - // if any, have been from the shared heap). Of course this assumes no - // copy will be called to deallocate what has been allocated after said - // copy was made: - // - // A x; - // A y (x); - // p = x.allocate (); - // y.deallocate (p); // Ouch. - // - return (x.buf_ == y.buf_) || (x.buf_->free_ && y.buf_->free_); - } - - friend bool - operator!= (small_vector_allocator x, small_vector_allocator y) noexcept - { - return !(x == y); - } - - // It might get instantiated but should not be called. - // - small_vector_allocator - select_on_container_copy_construction () const noexcept - { - return small_vector_allocator (nullptr); - } - - // propagate_on_container_copy_assignment = false - // propagate_on_container_move_assignment = false - - // Swap is not supported (see explanation in small_vector::swap()). - // - using propagate_on_container_swap = std::true_type; - - void - swap (small_vector_allocator&) = delete; - - // Shouldn't be needed except to satisfy some static_assert's. - // - template - struct rebind {using other = small_vector_allocator;}; - - private: - buffer_type* buf_; - }; - // Issues and limitations. // // - vector::reserve() may allocate more per the spec. But the three main @@ -167,13 +40,13 @@ LIBBUTL_MODEXPORT namespace butl // - swap() is deleted (see notes below). // template - class small_vector: private small_vector_buffer, - public std::vector> + class small_vector: private small_allocator_buffer, + public std::vector> { public: - using allocator_type = small_vector_allocator; - using buffer_type = small_vector_buffer; - using base_type = std::vector>; + using buffer_type = small_allocator_buffer; + using allocator_type = small_allocator; + using base_type = std::vector; small_vector () : base_type (allocator_type (this)) @@ -263,7 +136,7 @@ LIBBUTL_MODEXPORT namespace butl // VC15U1). // #if defined(_MSC_VER) && _MSC_VER <= 1910 - if (v.size () < N) + if (v.size () <= N) { clear (); for (T& x: v) -- cgit v1.1