managedFileSwap.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 MANAGEDFILESWAP_H
#define MANAGEDFILESWAP_H

#include "managedSwap.h"
#include <stdio.h>
#include <unistd.h>
#include <map>
#include <queue>
#include <libaio.h>
#include <signal.h>
#include <unordered_map>
#include <sys/types.h>
#include <unistd.h>

//Test classes
#ifdef BUILD_TESTS
class managedFileSwap_Unit_SwapAllocation_Test;
class managedFileSwap_Integration_RandomAccess_Test;
class managedFileSwap_Integration_RandomAccessVariousSize_Test;
class managedFileSwap_Unit_SwapPolicy_Test;
#endif

namespace rambrain
{
enum pageChunkStatus {PAGE_FREE = 1 ,
                      PAGE_PART = 2 ,
                      PAGE_END = 4 ,
                      PAGE_WASREAD = 8 ,
                      PAGE_UNKNOWN_STATE = 16 
                     };

typedef uint64_t global_offset;

class pageFileLocation;

struct swapFileDesc {
    int fileno;
    global_bytesize currentSize;
};

struct aiotracker {
    struct iocb aio;
    int *tracker;
};

union glob_off_union {
    pageFileLocation *glob_off_next;
    managedMemoryChunk *chunk;
    glob_off_union() {
        chunk = NULL;
    };
};


class pageFileLocation
{
public:
    pageFileLocation ( unsigned int file, global_bytesize offset, global_bytesize size, pageChunkStatus status = PAGE_FREE ) :
        file ( file ), offset ( offset ), size ( size ), status ( status ), aio_ptr ( NULL ) {}

    unsigned int file ;
    global_bytesize offset ;
    global_bytesize size ;
    union glob_off_union glob_off_next;//
    pageChunkStatus status ;
    struct aiotracker *aio_ptr = NULL ;
    char aio_lock = 0 ;
};



class managedFileSwap;

class managedFileSwap : public managedSwap
{
public:

    managedFileSwap ( global_bytesize size, const char *filemask, global_bytesize oneFile = 0, bool enableDMA = false );
    virtual ~managedFileSwap();

    virtual void swapDelete ( managedMemoryChunk *chunk );
    virtual global_bytesize swapIn ( managedMemoryChunk **chunklist, unsigned int nchunks );
    virtual global_bytesize swapIn ( managedMemoryChunk *chunk );
    virtual global_bytesize swapOut ( managedMemoryChunk **chunklist, unsigned int nchunks );
    virtual global_bytesize swapOut ( managedMemoryChunk *chunk );
    virtual bool extendSwap ( global_bytesize size );
    virtual bool extendSwapByPolicy ( global_bytesize min_size );

    void setDMA ( bool arg1 );

    virtual void close();

    const unsigned int pageSize;


private:
    pageFileLocation determinePFLoc ( global_offset g_offset, global_bytesize length ) const;
    inline global_offset determineGlobalOffset ( const pageFileLocation &ref ) const;
    bool openSwapFiles();
    bool openSwapFileRange ( unsigned int start, unsigned int stop );
    void closeSwapFiles();

    const char *filemask;

    unsigned int pageFileNumber;
    global_bytesize pageFileSize;


    float swapFileResizeFrac = .1;

    struct swapFileDesc *swapFiles = NULL;

    void scheduleCopy ( rambrain::pageFileLocation &ref, void *ramBuf, int *tracker, bool reverse = false ) ;
    void copyMem ( rambrain::pageFileLocation &ref, void *ramBuf, bool reverse = false  )  ;

    inline void copyMem ( void *ramBuf, rambrain::pageFileLocation &ref ) {
        copyMem ( ref, ramBuf, true );
    }
    inline void scheduleCopy ( void *ramBuf, pageFileLocation &ref, int *parttracker ) {
        scheduleCopy ( ref, ramBuf, parttracker, true );
    }

    inline size_t getMemoryAlignment() const {
        return memoryAlignment;
    }


    //page file malloc:
    pageFileLocation *pfmalloc ( rambrain::global_bytesize size, rambrain::managedMemoryChunk *chunk );
    void pffree ( pageFileLocation *pagePtr );
    pageFileLocation *allocInFree ( pageFileLocation *freeChunk, global_bytesize size );

    std::map<global_offset, pageFileLocation *> free_space;
    std::map<global_offset, pageFileLocation *> all_space;


    bool enableDMA = false;
protected:
    bool deleteFilesOnExit = true;

    //sigEvent Handler:
    void asyncIoArrived ( rambrain::pageFileLocation *ref, struct io_event *aio );
    void completeTransactionOn ( rambrain::pageFileLocation *ref, bool lock = true );

    virtual bool checkForAIO();

    struct iocb aio_template;
    io_context_t aio_context = 0;
    unsigned int aio_max_transactions = 10240;
    struct io_event *aio_eventarr;
    pthread_mutex_t aioWaiterLock = PTHREAD_MUTEX_INITIALIZER;

    std::unordered_map<struct iocb *, pageFileLocation *> pendingAios;

    static managedFileSwap *instance;
    static void sigStat ( int signum );

    //Thread pool for asynchronous io:
    pthread_mutex_t io_submit_lock = PTHREAD_MUTEX_INITIALIZER;
    pthread_cond_t io_submit_cond = PTHREAD_COND_INITIALIZER;
    unsigned int io_submit_num_threads = 1;
    pthread_t *io_submit_threads;
    pthread_t io_waiter_thread;
    pthread_t io_arrive_thread;

    std::queue<struct iocb *> io_submit_requests;

    void my_io_submit ( struct iocb *aio );
    static void *io_submit_worker ( void *ptr );
    static void *io_arrrive_worker ( void *ptr );

    bool io_arrive_work = true;

    bool cleanupCachedElements ( rambrain::global_bytesize minimum_size = 0 );
    virtual void invalidateCacheFor ( managedMemoryChunk &chunk );

    global_bytesize getFreeDiskSpace();

    //Test classes
#ifdef BUILD_TESTS
    friend class ::managedFileSwap_Unit_SwapAllocation_Test;
    friend class ::managedFileSwap_Integration_RandomAccess_Test;
    friend class ::managedFileSwap_Integration_RandomAccessVariousSize_Test;
    friend class ::managedFileSwap_Unit_SwapPolicy_Test;
#endif
};

}


#endif