stack_allocator.h

Go to the documentation of this file.

/*
 * Copyright (C) 2020 Robin Gareus <robin@gareus.org>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
#ifndef PBD_STACK_ALLOCATOR_H
#define PBD_STACK_ALLOCATOR_H
 
#include <boost/type_traits/aligned_storage.hpp>
#include <limits>
 
#include "pbd/libpbd_visibility.h"
 
#if 0
# include <cstdio>
# define DEBUG_STACK_ALLOC(...) printf (__VA_ARGS__)
#else
# define DEBUG_STACK_ALLOC(...)
#endif
 
namespace PBD {
 
template <class T, std::size_t stack_capacity>
class /*LIBPBD_API*/ StackAllocator
{
public:
#if 0 /* may be needed for compatibility */
        typedef typename std::allocator<T>::value_type value_type;
        typedef typename std::allocator<T>::size_type size_type;
        typedef typename std::allocator<T>::difference_type difference_type;
        typedef typename std::allocator<T>::pointer pointer;
        typedef typename std::allocator<T>::const_pointer const_pointer;
        typedef typename std::allocator<T>::reference reference;
        typedef typename std::allocator<T>::const_reference const_reference;
#else
        typedef T                 value_type;
        typedef std::size_t       size_type;
        typedef std::ptrdiff_t    difference_type;
        typedef value_type*       pointer;
        typedef const value_type* const_pointer;
        typedef value_type&       reference;
        typedef const value_type& const_reference;
#endif
 
        template <class U>
        struct rebind {
                typedef StackAllocator<U, stack_capacity> other;
        };
 
        StackAllocator ()
                : _ptr ((pointer)&_buf)
        { }
 
        StackAllocator (const StackAllocator&)
                : _ptr ((pointer)&_buf)
        { }
 
        template <typename U, size_t other_capacity>
        StackAllocator (const StackAllocator<U, other_capacity>&)
                : _ptr ((pointer)&_buf)
        { }
 
        /* inspired by http://howardhinnant.github.io/stack_alloc.h */
        pointer allocate (size_type n, void* hint = 0)
        {
                if ((pointer)&_buf + stack_capacity >= _ptr + n) {
                        DEBUG_STACK_ALLOC ("[%p] Allocate %ld item(s) of size %zu on the stack. used: %ld\n", (pointer)&_buf, n, sizeof (T), (_ptr - (pointer)&_buf));
                        pointer rv = _ptr;
                        _ptr += n;
                        return rv;
                } else {
                        DEBUG_STACK_ALLOC ("[%p] Allocate using new (%ld * %zu)\n", (pointer)&_buf, n, sizeof (T));
                        return static_cast<pointer> (::operator new (n * sizeof (T)));
                }
        }
 
        void deallocate (pointer p, size_type n)
        {
                DEBUG_STACK_ALLOC ("[%p] Deallocate: %ld item(s), at %p (offset: %ld) used: %ld\n", (pointer)&_buf, n, p, p - (pointer)&_buf, (_ptr - (pointer)&_buf));
                if (pointer_in_buffer (p)) {
                        if (p + n == _ptr) {
                                DEBUG_STACK_ALLOC ("[%p] Deallocate: pop item from the top of the stack %ld\n", (pointer)&_buf, n);
                                _ptr = p;
                        } else {
                                DEBUG_STACK_ALLOC ("[%p] Deallocate: ignored. Item is not at the top of the stack %ld\n", (pointer)&_buf, n);
                        }
                } else {
                        DEBUG_STACK_ALLOC ("[%p] Deallocate: using delete %p %ld\n", (pointer)&_buf, p, n);
                        ::operator delete (p);
                }
        }
 
        size_type max_size () const throw ()
        {
                return std::numeric_limits<size_type>::max () / sizeof (T);
        }
 
        bool operator== (StackAllocator const& a) const
        {
                return &_buf == &a._buf;
        }
 
        bool operator!= (StackAllocator const& a) const
        {
                return &_buf != &a._buf;
        }
 
        template <class U>
        void destroy (U* const p)
        {
                p->~U ();
        }
 
        template <class U>
        void construct (U* const p)
        {
                new (p) U ();
        }
 
#if __cplusplus > 201103L || defined __clang__
        template <class U, class A>
        void construct (U* const p, A* const a)
        {
                new (p) U (a);
        }
#else
        template <class U, class A>
        void construct (U* const p, A const& a)
        {
                new (p) U (a);
        }
#endif
 
private:
        StackAllocator& operator= (const StackAllocator&);
 
        bool pointer_in_buffer (pointer const p)
        {
                return ((pointer const)&_buf <= p && p < (pointer const)&_buf + stack_capacity);
        }
 
        typedef typename boost::aligned_storage<sizeof (T) * stack_capacity, 16>::type align_t;
 
        align_t _buf;
        pointer _ptr;
};
 
} // namespace PBD
 
#endif