cyclicManagedMemory.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 CYCLICMANAGEDMEMORY_H
#define CYCLICMANAGEDMEMORY_H

#include "managedMemory.h"

namespace rambrain
{
struct cyclicAtime {
    managedMemoryChunk *chunk;
    cyclicAtime *next; 
    cyclicAtime *prev;
};


enum backlog_action {UNKNOWN, REGISTER, DELETE, SWAPOUT, SWAPIN, DECAY, TOUCH, CHECK};

union backlog_value {
    memoryID id;
    global_bytesize size;
};
struct backlog_entry {
    backlog_action action = UNKNOWN;
    backlog_value value;
};




class cyclicManagedMemory : public managedMemory
{
public:
    cyclicManagedMemory ( rambrain::managedSwap *swap, rambrain::global_bytesize size );
    virtual ~cyclicManagedMemory();

    void printCycle() const;
    void printMemUsage() const;
    bool checkCycle();

    bool setPreemptiveLoading ( bool preemptive );
    bool setPreemptiveUnloading ( bool preemptive );

    struct chain {
        cyclicAtime *from, *to;
    };



private:
    virtual bool swapIn ( managedMemoryChunk &chunk );
    virtual swapErrorCode swapOut ( global_bytesize min_size );
    virtual bool touch ( managedMemoryChunk &chunk );
    virtual void untouch ( managedMemoryChunk &chunk );
    virtual void schedulerRegister ( managedMemoryChunk &chunk );
    virtual void schedulerDelete ( managedMemoryChunk &chunk );
    void decay ( global_bytesize bytes );


    //loop pointers:
    cyclicAtime *active = NULL;
    cyclicAtime *counterActive = NULL;
    cyclicAtime *preemptiveStart = NULL;

    float swapOutFrac = .8;
    float swapInFrac = .9;

    bool preemtiveSwapIn = true;
    bool preemtiveSwapOut = true;
    global_bytesize preemptiveBytes = 0;
    unsigned int consecutivePreemptiveTransactions = 0;
    unsigned int preemptiveSinceLast = 0;

    static pthread_mutex_t cyclicTopoLock;

    double preemptiveTurnoffFraction = .01;


    struct cyclicManagedMemory::chain filterChain ( chain &toFilter, const memoryStatus *separateStatus, bool *preemptiveLoaded = NULL );
    static void insertBefore ( cyclicAtime *pos, chain separated );
    static void printChain ( const char *name, const chain mchain );

    void printBacklog() const;
    static const unsigned int backlog_size = 100;
    backlog_entry backlog[backlog_size];
    unsigned int backlog_pos = 0;

};

#define MUTUAL_CONNECT(A,B) A->next = B; B->prev = A;

#define BACKLOG_ADD_SIZE(maction,mvalue) {backlog[backlog_pos].action  = maction;backlog[backlog_pos].value.size= mvalue;backlog_pos=(backlog_pos+1)%backlog_size;};
#define BACKLOG_ADD_ID(maction,mvalue) {backlog[backlog_pos].action  = maction;backlog[backlog_pos].value.id= mvalue ;backlog_pos=(backlog_pos+1)%backlog_size;};


}

#endif