Allocator.h

Go to the documentation of this file.

/*******************************************************************************
*
* Copyright (c) 2010 Philipp Werner <philipp.werner@st.ovgu.de>
* All rights reserved.
*
*    Redistribution and use in source and binary forms, with or without
*    modification, are permitted provided that the following conditions
*    are met:
*
*    * Redistributions of source code must retain the above copyright
*      notice, this list of conditions and the following disclaimer.
*
*    * Redistributions in binary form must reproduce the above copyright
*      notice, this list of conditions and the following disclaimer in
*      the documentation and/or other materials provided with the
*      distribution.
*
*    * Neither the name of the copyright holders nor the names of
*      contributors may be used to endorse or promote products derived
*      from this software without specific prior written permission.
*
*
*    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
*    IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
*    TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
*    PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
*    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
*    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
*    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
*    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
*    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
*    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
*    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*
* $Id$
*
******************************************************************************/

#ifndef __ALLOCATOR_H_811BED41A54BF9__
#define __ALLOCATOR_H_811BED41A54BF9__


#include <stdint.h>

#include "object/RawStorage.h"
#include "object/PlacementNew.h"

// Used for RawStorageAllocator
#include "logging/singleton.h"


namespace object {

    template <class tag, uint64_t mem_size>
    class RawStorageAllocator {

            typedef RawStorage<mem_size> ThisType;
        public:

            typedef typename ThisType::SizeT SizeT;

        protected:

            static ThisType & instance() {
                return logging::detail::singleton<ThisType>::instance();
            }

        public:

            static uint8_t * alloc(SizeT bytes) {
                return instance().alloc(bytes);
            }

            static void free(uint8_t * p) {
                instance().free(p);
            }

            template <typename T>
            static T * alloc_array(SizeT num) {
                return reinterpret_cast<T *>(alloc(sizeof(T) * num));
            }

            template <typename T>
            static void free_array(T * p) {
                return free(reinterpret_cast<uint8_t *>(p));
            }

            template <typename T>
            static void destroy(T * p) {
                p->~T();
                free(reinterpret_cast<uint8_t *>(p));
            }
    };


    template <class tag, uint64_t mem_size>
    class OneBlockAllocator {

            struct Buffer {
                FOR_FAMOUSO_ASSERT_ONLY(bool allocated);
                uint8_t data[mem_size];

                typedef typename SmallestUnsignedTypeSelector<mem_size>::type SizeT;

                Buffer() FOR_FAMOUSO_ASSERT_ONLY(: allocated(false)) {
                }

                uint8_t * alloc(SizeT n) {
                    if (!n || n > mem_size)
                        return 0;
                    else {
                        FAMOUSO_ASSERT(!allocated);
                        FOR_FAMOUSO_ASSERT_ONLY(allocated = true);
                        return data;
                    }
                }

                void free(uint8_t *) {
                    FAMOUSO_ASSERT(allocated);
                    FOR_FAMOUSO_ASSERT_ONLY(allocated = false);
                }
            };

        public:

            typedef typename Buffer::SizeT SizeT;

        protected:

            static Buffer & instance() {
                static Buffer buffer;
                return buffer;
            }

        public:

            static uint8_t * alloc(SizeT bytes) {
                return instance().alloc(bytes);
            }

            static void free(uint8_t * p) {
                instance().free(p);
            }

            template <typename T>
            static T * alloc_array(SizeT num) {
                return reinterpret_cast<T *>(alloc(sizeof(T) * num));
            }

            template <typename T>
            static void free_array(T * p) {
                return free(reinterpret_cast<uint8_t *>(p));
            }

            template <typename T>
            static void destroy(T * p) {
                p->~T();
                free(reinterpret_cast<uint8_t *>(p));
            }
    };

#ifndef __AVR__

    class NewAllocator {
        public:
            typedef unsigned int SizeT;

            static uint8_t * alloc(SizeT bytes) {
                return new(std::nothrow) uint8_t [bytes];
            }

            static void free(uint8_t * p) {
                delete [] p;
            }

            template <typename T>
            static T * alloc_array(SizeT num) {
                return reinterpret_cast<T*>(alloc(sizeof(T) * num));
            }

            template <typename T>
            static void free_array(T * p) {
                return free(reinterpret_cast<uint8_t *>(p));
            }

            template <typename T>
            static void destroy(T * p) {
                p->~T();
                free(reinterpret_cast<uint8_t *>(p));
            }
    };
#endif


#ifndef DEFAULT_RAWSTORAGEALLOCATOR_MEM_SIZE

#ifdef __AVR__
#define DEFAULT_RAWSTORAGEALLOCATOR_MEM_SIZE 0xff
#else

#define DEFAULT_RAWSTORAGEALLOCATOR_MEM_SIZE 0xffff
#endif

#endif

    class DefaultRawStorageAllocatorTag;

#ifdef __AVR__
    typedef RawStorageAllocator<DefaultRawStorageAllocatorTag, DEFAULT_RAWSTORAGEALLOCATOR_MEM_SIZE> Allocator;
#else

    typedef NewAllocator Allocator;
#endif

} // namespace object


template <typename tag, uint64_t mem_size>
void * operator new(std::size_t size, const object::RawStorageAllocator<tag, mem_size> & allocator) throw() {
    return allocator.alloc(size);
}


#ifndef __AVR__

void * operator new(std::size_t size, const object::NewAllocator & allocator) throw() {
    return allocator.alloc(size);
}
#endif


#endif // __ALLOCATOR_H_811BED41A54BF9__