Allocator.h

Go to the documentation of this file.

/*
  ZynAddSubFX - a software synthesizer
 
  Allocator.h - RT-Safe Memory Allocator
  Copyright (C) 2016 Mark McCurry
 
  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.
*/
#pragma once
#include <cstdlib>
#include <utility>
#include <new>
 
namespace zyncarla {

class Allocator
{
    public:
        Allocator(void);
        Allocator(const Allocator&) = delete;
        virtual ~Allocator(void);
 
        virtual void *alloc_mem(size_t mem_size) = 0;
        virtual void dealloc_mem(void *memory) = 0;

        template <typename T, typename... Ts>
        T *alloc(Ts&&... ts)
        {
            void *data = alloc_mem(sizeof(T));
            if(!data) {
                rollbackTransaction();
                throw std::bad_alloc();
            }
            append_alloc_to_memory_transaction(data);
            return new (data) T(std::forward<Ts>(ts)...);
        }

        template <typename T, typename... Ts>
        T *valloc(size_t len, Ts&&... ts)
        {
            T *data = (T*)alloc_mem(len*sizeof(T));
            if(!data) {
                rollbackTransaction();
                throw std::bad_alloc();
            }
            append_alloc_to_memory_transaction(data);
            for(unsigned i=0; i<len; ++i)
                new ((void*)&data[i]) T(std::forward<Ts>(ts)...);
 
            return data;
        }
 
        template <typename T>
        void dealloc(T*&t)
        {
            if(t) {
                t->~T();
                dealloc_mem((void*)t);
                t = nullptr;
            }
        }
 
        //Destructor Free Version
        template <typename T>
        void devalloc(T*&t)
        {
            if(t) {
                dealloc_mem(t);
                t = nullptr;
            }
        }
 
        template <typename T>
        void devalloc(size_t elms, T*&t)
        {
            if(t) {
                for(size_t i=0; i<elms; ++i)
                    (t+i)->~T();
 
                dealloc_mem(t);
                t = nullptr;
            }
        }
 
    void beginTransaction();
    void endTransaction();
 
    virtual void addMemory(void *, size_t mem_size) = 0;
 
    //Return true if the current pool cannot allocate n chunks of chunk_size
    virtual bool lowMemory(unsigned n, size_t chunk_size) const = 0;
    bool memFree(void *pool) const;
 
    //returns number of pools
    int memPools() const;
 
    int freePools() const;
 
    unsigned long long totalAlloced() const;
 
    struct AllocatorImpl *impl;
 
private:
    const static size_t max_transaction_length = 256;
 
    void* transaction_alloc_content[max_transaction_length];
    size_t transaction_alloc_index;
    bool transaction_active;
 
    void rollbackTransaction();

    void append_alloc_to_memory_transaction(void *new_memory) {
        if (transaction_active) {
            if (transaction_alloc_index < max_transaction_length) {
                transaction_alloc_content[transaction_alloc_index++] = new_memory;
            }
            // TODO add log about transaction too long and memory transaction
            // safety net being disabled
        }
    }
 
};

class AllocatorClass : public Allocator
{
    public:
        void *alloc_mem(size_t mem_size);
        void dealloc_mem(void *memory);
        void addMemory(void *, size_t mem_size);
        bool lowMemory(unsigned n, size_t chunk_size) const;
        using Allocator::Allocator;
};
typedef AllocatorClass Alloc;

class DummyAllocator : public Allocator
{
    void not_allowed() const {
        throw "(de)allocation forbidden"; // TODO: std exception
    }
public:
    void *alloc_mem(size_t ) { return not_allowed(), nullptr; }
    void dealloc_mem(void* ) { not_allowed(); } // TODO: more functions?
    void addMemory(void *, size_t ) { not_allowed(); }
    bool lowMemory(unsigned , size_t ) const { return not_allowed(), true; }
    using Allocator::Allocator;
};
 
extern DummyAllocator DummyAlloc;

 
 }