managedMemory.h

Go to the documentation of this file.

/*   rambrain - a dynamical physical memory extender
 *   Copyright (C) 2015 M. Imgrund, A. Arth
 *   mimgrund (at) mpifr-bonn.mpg.de
 *   arth (at) usm.uni-muenchen.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 3 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, see <http://www.gnu.org/licenses/>.
 */

#ifndef MANAGEDMEMORY_H
#define MANAGEDMEMORY_H

#include <stdlib.h>
#include <map>
#include <pthread.h>

#ifdef SWAPSTATS
#include <signal.h>
#ifdef LOGSTATS
#include <chrono>
#include "timer.h"
#endif
#endif

#include "managedMemoryChunk.h"
#include "exceptions.h"


//Test classes
#ifdef BUILD_TESTS
class managedFileSwap_Unit_ManualSwapping_Test;
class managedFileSwap_Unit_ManualSwappingDelete_Test;
class managedFileSwap_Unit_ManualMultiSwapping_Test;
class managedFileSwap_Unit_CheckSwapStats_Test;
class cyclicManagedMemory_Integration_ArrayAccess_Test;
#endif

namespace rambrain
{
class managedFileSwap;
class managedDummySwap;
class managedSwap;
template<class T, int dim>
class managedPtr;
class managedMemory
{
public:
    managedMemory ( managedSwap *swap, global_bytesize size = gig );
    virtual ~managedMemory();

    void closeSwap();

    //Memory Management options
    bool setMemoryLimit ( global_bytesize size );
    inline global_bytesize getMemoryLimit () const {
        return memory_max;
    }
    global_bytesize getUsedMemory() const;
    global_bytesize getSwappedMemory() const;
    global_bytesize getFreeSwapMemory() const;
    global_bytesize getTotalSwapMemory() const;


    bool setOutOfSwapIsFatal ( bool fatal = true );


    //Chunk Management
    bool prepareUse ( rambrain::managedMemoryChunk &chunk, bool acquireLock = true );
    bool setUse ( memoryID id );
    bool unsetUse ( memoryID id );
    bool setUse ( managedMemoryChunk &chunk, bool writeAccess );
    bool unsetUse ( managedMemoryChunk &chunk , unsigned int no_unsets = 1 );


#ifdef PARENTAL_CONTROL
    //Tree Management
    unsigned int getNumberOfChildren ( const memoryID &id );
    void printTree ( managedMemoryChunk *current = NULL, unsigned int nspaces = 0 );

    static const memoryID root;
    static memoryID parent;
    //We need the following two to correctly initialize class hierarchies:
    static bool threadSynced;
    static pthread_mutex_t parentalMutex;
    static pthread_cond_t parentalCond;
    static pthread_t creatingThread;
    void recursiveMfree ( memoryID id );
#else
    void linearMfree();
#endif
    static managedMemory *defaultManager;
    static const memoryID invalid;
    static void signalSwappingCond();
protected:
    managedMemoryChunk *mmalloc ( global_bytesize sizereq );
    bool mrealloc ( memoryID id, global_bytesize sizereq );
    void mfree ( rambrain::memoryID id, bool inCleanup = false );
    managedMemoryChunk &resolveMemChunk ( const memoryID &id );


    enum swapErrorCode {
        ERR_SUCCESS,
        ERR_SWAPFULL ,
        ERR_MORETHANTOTALRAM,
        ERR_NOTENOUGHCANDIDATES
    };
    virtual swapErrorCode swapOut ( global_bytesize min_size ) = 0;
    virtual bool swapIn ( memoryID id );
    virtual bool swapIn ( managedMemoryChunk &chunk ) = 0;
    virtual bool touch ( managedMemoryChunk &chunk ) = 0;
    virtual void untouch ( managedMemoryChunk &chunk ) = 0;
    virtual void schedulerRegister ( managedMemoryChunk &chunk ) = 0;
    virtual void schedulerDelete ( managedMemoryChunk &chunk ) = 0;

    bool ensureEnoughSpace ( global_bytesize sizereq, managedMemoryChunk *orIsSwappedin = NULL );

    //Swap Storage manager iface:
    managedSwap *swap = 0;

    global_bytesize memory_max; //1GB
    global_bytesize memory_used = 0;
    global_bytesize memory_swapped = 0;
    global_bytesize memory_tobefreed = 0;
    bool outOfSwapIsFatal = true;

    std::map<memoryID, managedMemoryChunk *> memChunks;

    memoryAtime atime = 0;
    memoryID memID_pace = 1;


    managedMemory *previousManager;
    static bool Throw ( memoryException e );

    static pthread_mutex_t stateChangeMutex;
    //Signalled after every swapin. Synchronization is happening via stateChangeMutex
    static pthread_cond_t swappingCond;
    /*static pthread_cond_t topologicalCond;*/

    template<class T, int dim>
    friend class managedPtr;
    friend class managedSwap;
    friend class managedFileSwap;
    friend class managedDummySwap;
    //Test classes
#ifdef BUILD_TESTS
    friend class ::managedFileSwap_Unit_ManualSwapping_Test;
    friend class ::managedFileSwap_Unit_ManualMultiSwapping_Test;
    friend class ::managedFileSwap_Unit_ManualSwappingDelete_Test;
    friend class ::cyclicManagedMemory_Integration_ArrayAccess_Test;
    friend class ::managedFileSwap_Unit_CheckSwapStats_Test;
    friend managedSwap *configTestGetSwap ( managedMemory *man );
#endif

#ifdef SWAPSTATS
protected:
    global_bytesize n_swap_out = 0;
    global_bytesize n_swap_in = 0;


    global_bytesize swap_out_scheduled_bytes = 0;
    global_bytesize swap_in_scheduled_bytes = 0;
    global_bytesize swap_out_bytes = 0;
    global_bytesize swap_in_bytes = 0;

    global_bytesize swap_out_bytes_last = 0;
    global_bytesize swap_in_bytes_last = 0;

    global_bytesize swap_hits = 0;
    global_bytesize swap_misses = 0;
#endif

    bool waitForSwapin ( managedMemoryChunk &chunk, bool keepSwapLock = false );
    bool waitForSwapout ( managedMemoryChunk &chunk, bool keepSwapLock = false );
    void claimUsageof ( global_bytesize bytes, bool rambytes, bool used );
    void claimTobefreed ( global_bytesize bytes, bool tobefreed );
    void waitForAIO();

    size_t memoryAlignment = 1;
#ifdef LOGSTATS
    static FILE *logFile;
    static bool firstLog;
#endif

public:
#ifdef SWAPSTATS
    void printSwapstats() const;
    void resetSwapstats();
    double getHitsOverMisses();

    double getTotalSwappedOutBytes() {
        return swap_out_bytes;
    };
    double getTotalSwappedInBytes() {
        return swap_in_bytes;
    };

    static void sigswapstats ( int sig );
#endif
    static void versionInfo();
};

}

#endif