pool.h

Go to the documentation of this file.

/*
 * Copyright (C) 1998-2015 Paul Davis <paul@linuxaudiosystems.com>
 * Copyright (C) 2009-2014 David Robillard <d@drobilla.net>
 * Copyright (C) 2010 Carl Hetherington <carl@carlh.net>
 * Copyright (C) 2015-2022 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.
 */
 
#pragma once
 
#include <string>
#include <vector>
 
#include <glibmm/threads.h>
 
#include "pbd/libpbd_visibility.h"
#include "pbd/ringbuffer.h"
 
namespace PBD {
 
typedef void (*PoolDumpCallback) (size_t, void*);
 
class LIBPBD_API Pool
{
public:
        Pool (std::string name, unsigned long item_size, unsigned long nitems, PoolDumpCallback cb = NULL);
        virtual ~Pool ();
 
        virtual void* alloc ();
        virtual void  release (void*);
 
        std::string name () const
        {
                return _name;
        }
        guint available () const
        {
                return free_list.read_space ();
        }
        guint used () const
        {
                return free_list.bufsize () - available ();
        }
        guint total () const
        {
                return free_list.bufsize ();
        }
 
protected:
        PBD::RingBuffer<void*> free_list; 
 
        std::string _name;
 
private:
        void*            _block; 
        PoolDumpCallback _dump;  
#ifndef NDEBUG
        unsigned long max_usage;
#endif
};
 
class LIBPBD_API SingleAllocMultiReleasePool : public Pool
{
public:
        SingleAllocMultiReleasePool (std::string name, unsigned long item_size, unsigned long nitems);
        ~SingleAllocMultiReleasePool ();
 
        virtual void* alloc ();
        virtual void  release (void*);
 
private:
        Glib::Threads::Mutex m_lock;
};
 
class LIBPBD_API MultiAllocSingleReleasePool : public Pool
{
public:
        MultiAllocSingleReleasePool (std::string name, unsigned long item_size, unsigned long nitems);
        ~MultiAllocSingleReleasePool ();
 
        virtual void* alloc ();
        virtual void  release (void*);
 
private:
        Glib::Threads::Mutex m_lock;
};
 
class LIBPBD_API PerThreadPool;
 
class LIBPBD_API CrossThreadPool : public Pool
{
public:
        CrossThreadPool (std::string n, unsigned long isize, unsigned long nitems, PerThreadPool*, PoolDumpCallback);
 
        void* alloc ();
        void  push (void*);
 
        PerThreadPool* parent () const
        {
                return _parent;
        }
 
        bool  empty ();
        guint pending_size () const
        {
                return pending.read_space ();
        }
 
        void flush_pending ();
        void flush_pending_with_ev (void*);
 
private:
        PBD::RingBuffer<void*> pending;
        PerThreadPool*         _parent;
};
 
class LIBPBD_API PerThreadPool
{
public:
        PerThreadPool ();
 
        const Glib::Threads::Private<CrossThreadPool>& key () const
        {
                return _key;
        }
 
        void create_per_thread_pool (std::string name, unsigned long item_size, unsigned long nitems, PoolDumpCallback cb = NULL);
 
        CrossThreadPool* per_thread_pool (bool must_exist = true);
 
        bool has_per_thread_pool ();
        void set_trash (PBD::RingBuffer<CrossThreadPool*>* t);
        void add_to_trash (CrossThreadPool*);
 
private:
        Glib::Threads::Private<CrossThreadPool> _key;
        std::string                             _name;
 
        Glib::Threads::Mutex               _trash_mutex;
        PBD::RingBuffer<CrossThreadPool*>* _trash;
};
 
} // namespace PBD