fileManager.h

Go to the documentation of this file.

// File: $Id$
// Author: K. John Wu <John.Wu at acm.org>
//         Lawrence Berkeley National Laboratory
// Copyright 2000-2012 University of California
#ifndef IBIS_FILEMANAGER_H
#define IBIS_FILEMANAGER_H








#include "util.h"

#include <set>          // std::set
#include <map>          // std::map

class FASTBIT_CXX_DLLSPEC ibis::fileManager {
public:

    enum ACCESS_PREFERENCE {
        MMAP_LARGE_FILES,       // files > minMapSize are mapped if possible
        PREFER_READ,            // read the whole file into memory
        PREFER_MMAP             // try to use mmap if possible
    };

    template<typename T>
    int getFile(const char* name, array_t<T>& arr,
                ACCESS_PREFERENCE pref=MMAP_LARGE_FILES);
    template<typename T>
    int tryGetFile(const char* name, array_t<T>& arr,
                   ACCESS_PREFERENCE pref=MMAP_LARGE_FILES);

    void printStatus(std::ostream& out) const;
    void flushFile(const char* name);
    void flushDir(const char* name);
    void clear();

    static fileManager& instance();
    static time_t iBeat() {return hbeat++;}
    const double& pageCount() const {return page_count;}
    static uint32_t pageSize() {return pagesize;}
    inline void recordPages(off_t start, off_t stop);
    static inline void increaseUse(size_t inc, const char* evt);
    static inline void decreaseUse(size_t dec, const char* evt);
    void signalMemoryAvailable() const;

    class cleaner {
    public:
        virtual void operator()() const = 0;
        virtual ~cleaner() {};
    };
    void addCleaner(const cleaner* cl);
    void removeCleaner(const cleaner* cl);

    class roFile; // forward declaration of fileManager::roFile
    class storage; // forward declaration of fileManager::storage
#if defined(HAVE_FILE_MAP)
    class rofSegment; // forward declaration of fileManager::rofSegment
#endif
    friend class roFile;
    friend class storage;
    int getFile(const char* name, storage** st,
                ACCESS_PREFERENCE pref=MMAP_LARGE_FILES);
    int tryGetFile(const char* name, storage** st,
                   ACCESS_PREFERENCE pref=MMAP_LARGE_FILES);
    static storage* getFileSegment(const char* name, const int fdes,
                                   const off_t b, const off_t e);

    inline void gainReadAccess(const char* mesg) const;
    inline void releaseAccess(const char* mesg) const;
    class readLock {
    public:
        readLock(const char* m) : mesg(m) {
            ibis::fileManager::instance().gainReadAccess(m);
        }
        ~readLock() {
            ibis::fileManager::instance().releaseAccess(mesg);
        }
    private:
        const char* mesg; // mesg identifies the holder of the lock
    };

    static uint64_t currentCacheSize() {return maxBytes;}
    static int adjustCacheSize(uint64_t);
    static uint64_t bytesInUse() {return ibis::fileManager::totalBytes();}
    static uint64_t bytesFree();

    template <typename T>
    class buffer {
    public:
        buffer(size_t sz=0);
        ~buffer();

        T& operator[](size_t i) {return buf[i];}
        const T& operator[](size_t i) const {return buf[i];}
        T* address() const {return buf;}
        size_t size() const {return nbuf;}
        size_t resize(size_t sz=0);
        void swap(buffer<T>& other) throw () {
            T* btmp = buf;
            buf = other.buf;
            other.buf = btmp;
            size_t ntmp = nbuf;
            nbuf = other.nbuf;
            other.nbuf = ntmp;
        }

    private:
        T* buf; 
        size_t nbuf; 

        buffer(const buffer<T>&);
        buffer<T>& operator=(const buffer<T>&);
    }; // buffer

protected:
    fileManager();  // get its input parameter from ibis::gParameters()
    ~fileManager(); // it exists forever

    void recordFile(roFile*); // record a new storage

    // parameters for controlling the resource usage
    static ibis::util::sharedInt64 totalBytes;
    static uint64_t maxBytes;
    static unsigned int maxOpenFiles;

    // not implemented, to prevent compiler from generating these functions
    fileManager(const fileManager& rhs);
    fileManager& operator=(const fileManager& rhs);

private:
    typedef std::map< const char*, roFile*,
                      std::less< const char* > > fileList;
    typedef std::set< const cleaner* > cleanerList;
    typedef std::set< const char*, std::less< const char* > > nameList;
    fileList mapped; // files that are memory mapped
    fileList incore; // files that have been read into the main memory
    nameList reading;// files that are being read by the function getFile
    cleanerList cleaners; // list of external cleaners
    double page_count;
    uint32_t minMapSize;
    uint32_t nwaiting;
    pthread_cond_t readCond;

    mutable pthread_rwlock_t lock; // the multiple read single write lock
    mutable pthread_mutex_t mutex; // control access to incore and mapped
    mutable pthread_cond_t cond;   // conditional variable -- unload(), etc..

    static time_t hbeat;        // a simple counter, no mutex lock
    static uint32_t pagesize;

    int unload(size_t size);    // try to unload size bytes
    void invokeCleaners() const;// invoke external cleaners
    inline void gainWriteAccess(const char* m) const;

    class writeLock;
    class softWriteLock;
    friend class writeLock;
    friend class softWriteLock;
}; // class fileManager

class FASTBIT_CXX_DLLSPEC ibis::fileManager::storage {
public:
    storage();
    explicit storage(size_t n); // allocate n bytes
    virtual ~storage() {clear();}

    storage(const char* fname, const off_t begin, const off_t end);
    storage(const int fdes, const off_t begin, const off_t end);
    storage(const char* begin, const char* end);
    storage(const storage& rhs);
    storage& operator=(const storage& rhs);
    void copy(const storage& rhs);

    const char* filename() const {return name;}

    bool empty() const {return (m_begin == 0 || m_begin >= m_end);}
    size_t size() const {
        return (m_begin!=0 && m_begin<m_end ? m_end-m_begin : 0);}
    size_t bytes() const {
        return (m_begin!=0 && m_begin<m_end ? m_end-m_begin : 0);}
    void enlarge(size_t nelm=0);

    char* begin() {return m_begin;}
    const char* end() const {return m_end;}
    const char* begin() const {return m_begin;}
    char operator[](size_t i) const {return m_begin[i];}

    virtual void beginUse();
    virtual void endUse();
    unsigned inUse() const {return nref();}
    unsigned pastUse() const {return nacc;}

    virtual bool isFileMap() const {return false;}
    // IO functions
    virtual void printStatus(std::ostream& out) const;
    off_t read(const char* fname, const off_t begin, const off_t end);
    off_t read(const int fdes, const off_t begin, const off_t end);
    void write(const char* file) const;

    inline void swap(storage& rhs) throw ();
//      // compares storage objects according to starting addresses
//      struct less : std::binary_function< storage*, storage*, bool > {
//      bool operator()(const storage* x, const storage* y) const {
//          return (x->begin() < y->begin());
//      }
//      };

protected:
    char* name;         
    char* m_begin;      
    char* m_end;        
    unsigned nacc;      

    ibis::util::sharedInt32 nref;

    virtual void clear(); // free memory/close file
}; // class fileManager::storage

class FASTBIT_CXX_DLLSPEC ibis::fileManager::roFile
    : public ibis::fileManager::storage {
public:
    virtual ~roFile() {clear();}

    // functions for recording access statistics
    virtual void beginUse();
    virtual void endUse();
    // is the read-only file mapped ?
    virtual bool isFileMap() const {return (mapped != 0);}

    // IO functions
    virtual void printStatus(std::ostream& out) const;
    void read(const char* file);
#if defined(HAVE_FILE_MAP)
    void mapFile(const char* file);
#endif

//      // compares storage objects according to file names
//      struct less : std::binary_function< roFile*, roFile*, bool > {
//      bool operator()(const roFile* x, const roFile* y) const {
//          return strcmp(x->filename(), y->filename()) < 0;
//      }
//      };
protected:
    roFile();
    // Read the whole file into memory.
    void doRead(const char* file);
    // Read the specified segment of the file into memory.
    void doRead(const char* file, off_t b, off_t e);
#if defined(HAVE_FILE_MAP)
    void doMap(const char* file, off_t b, off_t e, int opt=0);
#endif

    float score() const {
        float sc = FLT_MAX;
        time_t now = time(0);
        if (opened >= now) {
            sc = static_cast<float>(1e-4 * size() + nacc);
        }
        else if (lastUse >= now) {
            sc = static_cast<float>(sqrt(5e-6*size()) + nacc +
                                    (now - opened));
        }
        else {
            sc = static_cast<float>((sqrt(1e-6*size() + now - opened) +
                                     (static_cast<double>(nacc) /
                                      (now - opened))) / (now - lastUse));
        }
        return sc;
    }

    friend class ibis::fileManager;
    virtual void clear(); // free memory/close file

    void printBody(std::ostream& out) const;

private:
    time_t opened; // time first created, presumably when the file was opened
    time_t lastUse; // time of last use
    unsigned mapped; // 0 not a mapped file, otherwise yes

#if defined(_WIN32) && defined(_MSC_VER)
    HANDLE fdescriptor; // HANDLE to the open file
    HANDLE fmap; // HANDLE to the mapping object
    LPVOID map_begin; // actual address returned by MapViewOfFile
#elif (HAVE_MMAP+0 > 0)
    int fdescriptor; // descriptor of the open file
    size_t fsize;    // the size of the mapped portion of file
    void *map_begin; // actual address returned by mmap
#endif

    // not implemented, to prevent automatic generation
    roFile(const roFile&);
    roFile& operator=(const roFile&);
}; // class fileManager::roFile

#if defined(HAVE_FILE_MAP)



class FASTBIT_CXX_DLLSPEC ibis::fileManager::rofSegment
    : public ibis::fileManager::roFile {
public:
    rofSegment(const char *fn, off_t b, off_t e);
    virtual ~rofSegment() {};
    virtual void printStatus(std::ostream& out) const;

private:
    rofSegment(); // no default constructor
    rofSegment(const rofSegment&); // no copy constructor
    rofSegment& operator=(const rofSegment&); // no assignment operator

    std::string filename_; // name of the file
    off_t begin_, end_;    // the start and the end address of the file map
}; // ibis::fileManager::rofSegment
#endif

class ibis::fileManager::writeLock {
public:
    writeLock(const char* m) : mesg(m)
    {ibis::fileManager::instance().gainWriteAccess(mesg);}
    ~writeLock() {ibis::fileManager::instance().releaseAccess(mesg);}
private:
    const char* mesg;

    writeLock(const writeLock&);
    writeLock& operator=(const writeLock&);
}; // ibis::fileManager::writeLock

class ibis::fileManager::softWriteLock {
public:
    softWriteLock(const char* m);
    ~softWriteLock();
    bool isLocked() const {return(locked_==0);}

private:
    const char* mesg;
    const int locked_;

    softWriteLock(const softWriteLock&);
    softWriteLock& operator=(const softWriteLock&);
}; // ibis::fileManager::softWriteLock

inline uint64_t ibis::fileManager::bytesFree() {
    if (maxBytes == 0)
        ibis::fileManager::instance();
    return (maxBytes > ibis::fileManager::totalBytes() ?
            maxBytes - ibis::fileManager::totalBytes() : 0);
} // ibis::fileManager::bytesFree

inline void ibis::fileManager::releaseAccess(const char* mesg) const {
    int ierr = pthread_rwlock_unlock(&lock);
    if (0 == ierr) {
        LOGGER(ibis::gVerbose > 9)
            << "fileManager::releaseAccess   on "
            << static_cast<const void*>(&lock) << " for " << mesg;
    }
    else {
        LOGGER(ibis::gVerbose >= 0)
            << "Warning -- fileManager::releaseAccess   on "
            << static_cast<const void*>(&lock) << " for " << mesg
            << " failed with the error code " << ierr << " -- "
            << strerror(ierr);
    }
} // ibis::fileManager::releaseAccess

inline void ibis::fileManager::gainReadAccess(const char* mesg) const {
    int ierr = pthread_rwlock_rdlock(&lock);
    if (0 == ierr) {
        LOGGER(ibis::gVerbose > 9)
            << "fileManager::gainReadAccess  on "
            << static_cast<const void*>(&lock) << " for " << mesg;
    }
    else {
        LOGGER(ibis::gVerbose >= 0)
            << "Warning -- fileManager::gainReadAccess  on "
            << static_cast<const void*>(&lock) << " for " << mesg
            << " failed with the error code " << ierr << " -- "
            << strerror(ierr);
    }
} // ibis::fileManager::gainReadAccess

inline void ibis::fileManager::gainWriteAccess(const char* mesg) const {
    int ierr = pthread_rwlock_wrlock(&lock);
    if (0 == ierr) {
        LOGGER(ibis::gVerbose > 9)
            << "fileManager::gainWriteAccess on "
            << static_cast<const void*>(&lock) << " for " << mesg;
    }
    else {
        LOGGER(ibis::gVerbose >= 0)
            << "Warning -- fileManager::gainWriteAccess on "
            << static_cast<const void*>(&lock) << " for " << mesg
            << " failed with the error code " << ierr << " -- "
            << strerror(ierr);
    }
} // ibis::fileManager::gainWriteAccess

inline void ibis::fileManager::recordPages(off_t start, off_t stop) {
    if (stop - start > 0) {
        start = (start / pagesize) * pagesize;
        page_count += ceil(static_cast<double>((stop - start)) / pagesize);
    }
} // ibis::fileManager::recordPages

inline void
ibis::fileManager::increaseUse(size_t inc, const char* evt) {
    ibis::fileManager::totalBytes += inc;
    LOGGER(inc > 0 && evt != 0 && *evt != 0 && ibis::gVerbose > 9)
        << evt << " added " << inc << " bytes to increase totalBytes to "
        << ibis::fileManager::totalBytes();
} // ibis::fileManager::increaseUse

inline void
ibis::fileManager::decreaseUse(size_t dec, const char* evt) {
    ibis::fileManager::totalBytes -= dec;
    LOGGER(dec > 0 && evt != 0 && *evt != 0 && ibis::gVerbose > 9)
        << evt << " removed " << dec << " bytes to decrease totalBytes to "
        << ibis::fileManager::totalBytes();
} // ibis::fileManager::decreaseUse

inline void
ibis::fileManager::storage::swap(ibis::fileManager::storage& rhs) throw () {
    {char* tmp = name; name = rhs.name; rhs.name = tmp;}
    {char* tmp = m_begin; m_begin = rhs.m_begin; rhs.m_begin = tmp;}
    {char* tmp = m_end; m_end = rhs.m_end; rhs.m_end = tmp;}
    {unsigned itmp = nacc; nacc = rhs.nacc; rhs.nacc = itmp;}
    //nref.swap(rhs.nref);
} // ibis::fileManager::storage::swap
#endif // IBIS_FILEMANAGER_H