toppers/allocator.hpp

解説を見る。

/*
 *  TOPPERS/C++ API Template Library
 *      Toyohashi Open Platform for Embedded Real-Time Systems/
 *      C++ API Template Library
 *
 *  Copyright (C) 2004 by TAKAGI Nobuhisa
 *
 *  上記著作権者は，以下の (1)〜(4) の条件か，Free Software Foundation
 *  によって公表されている GNU General Public License の Version 2 に記
 *  述されている条件を満たす場合に限り，本ソフトウェア（本ソフトウェア
 *  を改変したものを含む．以下同じ）を使用・複製・改変・再配布（以下，
 *  利用と呼ぶ）することを無償で許諾する．
 *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
 *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
 *      スコード中に含まれていること．
 *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
 *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
 *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
 *      の無保証規定を掲載すること．
 *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
 *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
 *      と．
 *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
 *        作権表示，この利用条件および下記の無保証規定を掲載すること．
 *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
 *        報告すること．
 *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
 *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
 *
 *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
 *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，その適用可能性も
 *  含めて，いかなる保証も行わない．また，本ソフトウェアの利用により直
 *  接的または間接的に生じたいかなる損害に関しても，その責任を負わない．
 *
 *  @(#) $Id: allocator.hpp,v 1.3 2004/04/19 01:36:10 takagi-n Exp $
 */

#ifndef TOPPERS_ALLOCATOR_HPP_
#define TOPPERS_ALLOCATOR_HPP_

#include <toppers/fmempool.hpp>
#include <toppers/vmempool.hpp>
#include <toppers/sync.hpp>
#include <new>
#include <cstddef>

namespace toppers
{

    template <typename T>
    class alignof
    {
        struct _
        {
            char a_;
            T b_;
        };

    public:
        static const std::size_t value = offsetof(_, b_);
    };

    namespace detail
    {

        union max_alignment_helper
        {
            long l;
#ifdef  TOPPERS_LONG_LONG
            TOPPERS_LONG_LONG ll;
#endif
            double d;
            long double ld;
        };

    }

    const std::size_t max_alignment = alignof<detail::max_alignment_helper>::value;

    template <typename T>
    class rounded_sizeof
    {
    public:
        static const std::size_t value = (sizeof(T) + max_alignment - 1) / max_alignment * max_alignment;
    };

    inline void throw_bad_alloc()
    {
        static std::bad_alloc x;
        throw x;
    }

    template <typename T, class Pool>
    class allocator
    {
        Pool pool_;

    public:
        typedef std::size_t size_type;
        typedef std::ptrdiff_t  different_type;
        typedef T* pointer;
        typedef const T* const_pointer;
        typedef T& reference;
        typedef const T& const_reference;
        typedef T value_type;

        template <typename T1>
        struct rebind
        {
            typedef allocator<T1, Pool> other;
        };

        allocator() throw() {}
        explicit allocator(const Pool& pool) throw() : pool_(pool) {}
        allocator(const allocator&) throw() {}
        template <typename T1>
        allocator(const allocator<T1, Pool>&) throw() {}
        ~allocator() throw() {}

        pointer address(reference x) const { return &x; }
        const_pointer address(const_reference x) const { return &x; }

        T* allocate(size_type n, const void* = 0)
        {
            if (n > 0)
            {
                void* p;
                if (pool_.get(n * sizeof(T), &p) == E_OK)
                    return static_cast<T*>(p);
                throw_bad_alloc();
            }
            return 0;
        }
        void deallocate(pointer p, size_type)
        {
            pool_.release(p);
        }

        size_type max_size() const throw()
        {
            return ~size_type(0) / sizeof(T);
        }

        void construct(pointer p, const T& value)
        {
            new(p) T(value);
        }
        void destroy(pointer p)
        {
            p->~T();
        }
    };

    template <std::size_t Size, class Pool>
    class fixed_sized_allocator
    {
        void (*handler_)();
        Pool pool_;

    public:
        explicit fixed_sized_allocator(std::new_handler handler = 0) : handler_(handler) {}

        template <typename Sync>
        void* allocate(Sync sync)
        {
            void* p;
            while (pool_.get(Size, &p, sync) != E_OK)
            {
                if (handler_ == 0)
                    throw_bad_alloc();
                (*handler_)();
            }
            return p;
        }
        void* allocate()
        {
            return allocate(forever);
        }
        void deallocate(void* p) throw()
        {
            pool_.release(p);
        }
        std::new_handler set_new_handler(std::new_handler handler)
        {
            std::new_handler prev = handler_;
            handler_ = handler;
            return prev;
        }
    };

    template <class Host, class Pool, template <std::size_t, class> class Allocator = fixed_sized_allocator>
    class fixed_sized_new
    {
    protected:

        ~fixed_sized_new() {}

    public:
        static void* operator new(std::size_t size) throw(std::bad_alloc)
        {
            TOPPERS_ASSERT(size <= rounded_sizeof<Host>::value);
            return allocator<rounded_sizeof<Host>::value>::get().allocate();
        }
        static void operator delete(void* p) throw()
        {
            allocator<rounded_sizeof<Host>::value>::get().deallocate(p);
        }


        template <typename Sync>
        static void* operator new(std::size_t size, Sync sync) throw(std::bad_alloc)
        {
            TOPPERS_ASSERT(size <= rounded_sizeof<Host>::value);
            return allocator<rounded_sizeof<Host>::value>::get().allocate(sync);
        }
        template <typename Sync>
        static void operator delete(void* p, Sync) throw()
        {
            allocator<rounded_sizeof<Host>::value>::get().deallocate(p);
        }

        static void* operator new(std::size_t size, const std::nothrow_t& nt) throw()
        {
            return operator new(size, nt, forever);
        }
        static void operator delete(void* p, const std::nothrow_t&) throw()
        {
            operator delete(p);
        }

        template <typename Sync>
        static void* operator new(std::size_t size, const std::nothrow_t&, Sync sync) throw()
        {
            void* p = 0;
            try
            {
                TOPPERS_ASSERT(size <= rounded_sizeof<Host>::value);
                p = allocator<rounded_sizeof<Host>::value>::get().allocate(sync);
            }
            catch (...)
            {
            }
            return p;
        }
        template <typename Sync>
        static void operator delete(void* p, const std::nothrow_t&, Sync) throw()
        {
            allocator<rounded_sizeof<Host>::value>::get().deallocate(p);
        }

        std::new_handler set_new_handler(std::new_handler handler)
        {
            return allocator<rounded_sizeof<Host>::value>::get().set_new_handler(handler);
        }

    private:
        template <std::size_t Size>
        struct allocator
        {
            // 静的データメンバにするとVisual C++.net 2003でコンパイルできなくなる。
            static Allocator<Size, Pool>& get()
            {
                static Allocator<Size, Pool> impl;
                return impl;
            }
        };
    };

    template <class Host, class Pool>
    class variable_sized_new
    {
        static FP handler_;
        static Pool pool_;

    protected:

        ~variable_sized_new() {}

    public:
        static void* operator new(std::size_t size) throw(std::bad_alloc)
        {
            void* p = 0;
            while (pool_.get(UINT(size), &p) != E_OK)
            {
                if (handler_ == 0)
                    throw_bad_alloc();
                (*handler_)();
            }
            return p;
        }
        static void operator delete(void* p) throw()
        {
            pool_.release(p);
        }

        template <typename Sync>
        static void* operator new(std::size_t size, Sync sync) throw(std::bad_alloc)
        {
            void* p = 0;
            while (pool_.get(size, &p, sync) != E_OK)
            {
                if (handler_ == 0)
                    throw_bad_alloc();
                (*handler_)();
            }
            return p;
        }
        template <typename Sync>
        static void operator delete(void* p, Sync) throw()
        {
            pool_.release(p);
        }

        static void* operator new(std::size_t size, const std::nothrow_t& nt) throw()
        {
            void* p = 0;
            try
            {
                p = operator new(size);
            }
            catch (...)
            {
            }
            return p;
        }
        static void operator delete(void* p, const std::nothrow_t&) throw()
        {
            operator delete(p);
        }

        template <typename Sync>
        static void* operator new(std::size_t size, const std::nothrow_t&, Sync sync) throw()
        {
            void* p = 0;
            try
            {
                p = operator new(size, sync);
            }
            catch (...)
            {
            }
            return p;
        }
        template <typename Sync>
        static void operator delete(void* p, const std::nothrow_t&, Sync sync) throw()
        {
            operator delete(p, sync);
        }

        static void* operator new[](std::size_t size) throw(std::bad_alloc)
        {
            return operator new(size);
        }
        static void operator delete[](void* p) throw()
        {
            operator delete(p);
        }

        template <typename Sync>
        static void* operator new[](std::size_t size, Sync sync) throw(std::bad_alloc)
        {
            return operator new(size, sync);
        }
        template <typename Sync>
        static void operator delete[](void* p, Sync) throw()
        {
            operator delete(p);
        }

        static void* operator new[](std::size_t size, const std::nothrow_t& nt) throw()
        {
            return operator new(size, nt);
        }
        static void operator delete[](void* p, const std::nothrow_t& nt) throw()
        {
            operator delete(p, nt);
        }

        template <typename Sync>
        static void* operator new[](std::size_t size, const std::nothrow_t& nt, Sync sync) throw()
        {
            return operator new(size, nt, sync);
        }
        template <typename Sync>
        static void operator delete[](void* p, const std::nothrow_t& nt, Sync sync) throw()
        {
            operator delete(p, nt, sync);
        }

        std::new_handler set_new_handler(std::new_handler handler)
        {
            std::new_handler prev = handler_;
            handler_ = handler;
            return prev;
        }
    };

    template <class Host, class Pool>
    FP variable_sized_new<Host, Pool>::handler_;

    template <class Host, class Pool>
    Pool variable_sized_new<Host, Pool>::pool_;


    template <std::size_t N = 32, std::size_t Size = 32>
    class fixed_simple_pool
    {
        union node
        {
            node* next;
            char data[Size];
            detail::max_alignment_helper force_aligner_;
        };
        node* top_;
        node buf_[N];

    public:
        fixed_simple_pool() : top_(buf_)
        {
            node* next = 0;
            for (node* cur = &buf_[N - 1]; cur != top_; cur--)
            {
                cur->next = next;
                next = cur;
            }
        }

        ER get(VP* p_blk)
        {
            node* p = top_;
            top_ = p->next;
            *p_blk = p;
            return E_OK;
        }

        ER get(VP* p_blk, int sync)
        {
            return get(p_blk);
        }

        ER get(UINT size, VP* p_blk)
        {
            if (size > Size)
                return E_PAR;
            node* p = top_;
            top_ = p->next;
            *p_blk = p;
            return E_OK;
        }

        ER get(UINT size, VP* p_blk, int sync)
        {
            return get(size, p_blk);
        }

        ER release(VP blk)
        {
            node* p = static_cast<node*>(blk);
            p->next = top_;
            top_ = p;
            return E_OK;
        }
    };

    template <std::size_t TotalSize = 256>
    class variable_simple_pool
    {
        char* top_;
        union
        {
            char buf_[TotalSize];
            detail::max_alignment_helper force_aligner_;
        };

    public:
        variable_simple_pool() : top_(buf_)
        {
        }

        ER get(UINT size, VP* p_blk)
        {
            typedef detail::max_alignment_helper    aligner_type;
            size = (size + sizeof(aligner_type) - 1) / sizeof(aligner_type) * sizeof(aligner_type);
            if (p_blk == 0)
                return E_PAR;
            if (top_ + size >= buf_ + TotalSize)
                return E_NOMEM;
            *p_blk = top_;
            top_ += size;
            return E_OK;
        }

        ER get(UINT size, VP* p_blk, int sync)
        {
            return get(size, p_blk);
        }

        ER release(VP blk)
        {
            return E_OK;
        }
    };

    template <std::size_t Size = 32>
    class fixed_new_pool
    {
    public:
        ER get(VP* p_blk)
        {
            if (p_blk == 0)
                return E_PAR;
            void* p = ::operator new(Size, std::nothrow);
            if (p == 0)
                return E_NOMEM;
            *p_blk = p;
            return E_OK;
        }

        ER get(VP* p_blk, int sync)
        {
            return get(p_blk);
        }

        ER get(UINT size, VP* p_blk)
        {
            if (size > Size)
                return E_PAR;
            return get(p_blk);
        }

        ER get(UINT size, VP* p_blk, int sync)
        {
            return get(size, p_blk);
        }

        ER release(VP blk)
        {
            ::operator delete(blk);
            return E_OK;
        }
    };

    class variable_new_pool
    {
    public:
        ER get(UINT size, VP* p_blk)
        {
            if (p_blk == 0)
                return E_PAR;
            void* p = ::operator new(size);
            if (p == 0)
                return E_NOMEM;
            *p_blk = p;
            return E_OK;
        }

        ER get(UINT size, VP* p_blk, int sync)
        {
            return get(size, p_blk);
        }

        ER release(VP blk)
        {
            ::operator delete(blk);
            return E_OK;
        }
    };

}

#endif  // ! TOPPERS_ALLOCATOR_HPP_

---

• Copyright © 2004 by TAKAGI Nobuhisa
• 本ソフトウェアはTOPPERSライセンスに基づいて配布されています。
• TRONは"The Real-time Operating system Nucleus"の略称です。
• ITRONは"Industrial TRON"の略称です。
• μITRONは"Micro Industrial TRON"の略称です。
• TRON、ITRON、およびμITRONは、特定の商品ないしは商品群を指す名称ではありません。
• TOPPERSは"Toyohashi OPen Platform for Embedded Real-time Systems"の略称、JSPは"Just Standard Profile"の略称です。
• 本ページ中の商品名は，各社の商標または登録商標です。