MemoryManager.h

Go to the documentation of this file.

/***************************************************************************
        MemoryManager.h  -  Manager for virtual and physical memory
                             -------------------
    begin                : Wed Aug 08 2001
    copyright            : (C) 2000 by Thomas Eschenbacher
    email                : Thomas.Eschenbacher@gmx.de
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   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.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef MEMORY_MANAGER_H
#define MEMORY_MANAGER_H

#include "config.h"
#include <stddef.h>  // for size_t

#include <QtGlobal>
#include <QDir>
#include <QHash>
#include <QMutex>
#include <QString>

#include "libkwave/LRU_Cache.h"

namespace Kwave
{
    class SwapFile;

    typedef int Handle;

    class MemoryManager
    {
    public:
        MemoryManager();

        virtual ~MemoryManager();

        void close();

        Kwave::Handle allocate(size_t size) Q_DECL_EXPORT;

        bool resize(Kwave::Handle handle, size_t size) Q_DECL_EXPORT;

        size_t sizeOf(Kwave::Handle handle) Q_DECL_EXPORT;

        void free(Kwave::Handle &handle) Q_DECL_EXPORT;

        void setPhysicalLimit(quint64 mb) Q_DECL_EXPORT;

        void setVirtualLimit(quint64 mb) Q_DECL_EXPORT;

        void setSwapDirectory(const QString &dir) Q_DECL_EXPORT;

        void setUndoLimit(quint64 mb) Q_DECL_EXPORT;

        quint64 undoLimit() const Q_DECL_EXPORT;

        quint64 totalPhysical() Q_DECL_EXPORT;

        static MemoryManager &instance() Q_DECL_EXPORT;

        void *map(Kwave::Handle handle) Q_DECL_EXPORT;

        void unmap(Kwave::Handle handle) Q_DECL_EXPORT;

        int readFrom(Kwave::Handle handle, unsigned int offset,
                     void *buffer, unsigned int length) Q_DECL_EXPORT;

        int writeTo(Kwave::Handle handle, unsigned int offset,
                    const void *buffer, unsigned int length) Q_DECL_EXPORT;

#ifdef DEBUG_MEMORY

        typedef struct {
            struct {
                quint64 handles; 
                quint64 bytes;   
                quint64 limit;   
                quint64 allocs;  
                quint64 frees;   
            } physical;

            struct {
                struct {
                    quint64 handles; 
                    quint64 bytes;   
                } mapped;
                struct {
                    quint64 handles; 
                    quint64 bytes;   
                } cached;
                struct {
                    quint64 handles; 
                    quint64 bytes;   
                } unmapped;
                quint64 limit;  
                quint64 allocs; 
                quint64 frees;  
            } swap;
        } statistic_t;
#endif

    protected:

        quint64 physicalUsed();

        quint64 virtualUsed();

        QString nextSwapFileName(Kwave::Handle handle);

        bool convertToVirtual(Kwave::Handle handle, size_t new_size);

        bool convertToPhysical(Kwave::Handle handle, size_t new_size);

        Kwave::Handle allocatePhysical(size_t size);

        void tryToMakePhysical(Kwave::Handle handle);

        Kwave::Handle allocateVirtual(size_t size);

    private:

        Kwave::Handle newHandle();

        bool freePhysical(size_t size);

        void unmapFromCache(Kwave::Handle handle);

        void dump(const char *function);

    private:

        typedef struct physical_memory_t {
            void  *m_data;     
            size_t m_size;     
            int    m_mapcount; 
        } physical_memory_t;

    private:

        quint64 m_physical_limit;

        quint64 m_physical_max;

        quint64 m_virtual_limit;

        QDir m_swap_dir;

        quint64 m_undo_limit;

        Kwave::LRU_Cache<Kwave::Handle, physical_memory_t> m_physical;

        QHash<Kwave::Handle, Kwave::SwapFile *> m_unmapped_swap;

        QHash<Kwave::Handle, Kwave::SwapFile *> m_mapped_swap;

        QHash<Kwave::Handle, Kwave::SwapFile *> m_cached_swap;

        QMutex m_lock;

        static Kwave::Handle m_last_handle;

#ifdef DEBUG_MEMORY

        statistic_t m_stats;
#endif /* DEBUG_MEMORY */
    };

}

#endif /* MEMORY_MANAGER_H */

//***************************************************************************
//***************************************************************************