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 (c) 2000-2016 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);

    // /// Obtain a read lock on the file manager.
    // inline void gainReadAccess(const char* mesg) const;
    // /// Release a read lock on the file manager.
    // inline void releaseAccess(const char* mesg) const;
    // /// management of the file manager should hold a readLock.
    // class readLock {
    // public:
    //  /// Constructor.  Acquires a read lock.
    //  readLock(const char* m) : mesg(m) {
    //      ibis::fileManager::instance().gainReadAccess(m);
    //  }
    //  /// Destructor.  Releases the read lock.
    //  ~readLock() {
    //      ibis::fileManager::instance().releaseAccess(mesg);
    //  }
    // private:
    //  /// A free-form message.  Typically used to identify the holder of
    //  /// the lock.
    //  const char* mesg;
    // };

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

    unsigned int getMaxOpenMmapFiles() const;
    uint64_t getMaxMmapBytes() const;

    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();
    ~fileManager();

    void recordFile(roFile*);
    void unrecordFile(roFile*);

    // 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;
    fileList incore;
    nameList reading;
    cleanerList cleaners;
    double page_count;
    uint32_t minMapSize;
    uint32_t nwaiting;
    pthread_cond_t readCond;

    //mutable pthread_rwlock_t lock;
    mutable pthread_mutex_t mutex;
    mutable pthread_cond_t cond;

    static time_t hbeat;
    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(char* addr, size_t num);
    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);

    virtual void* release();
    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);}
    int disconnectFile();

    // 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
    virtual void* release() {return 0;}

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

private:
    time_t opened;
    time_t lastUse;
    unsigned mapped;

#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

// /// A write lock for controlling access to the two internal lists.
// class ibis::fileManager::writeLock {
// public:
//     /// Constructor.  Acquires a write lock.
//     writeLock(const char* m) : mesg(m)
//     {ibis::fileManager::instance().gainWriteAccess(mesg);}
//     /// Destructor.  Releases the write lock.
//     ~writeLock() {ibis::fileManager::instance().releaseAccess(mesg);}
// private:
//     const char* mesg;

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

// /// A soft write lock for controlling access to the two internal lists.
// class ibis::fileManager::softWriteLock {
// public:
//     softWriteLock(const char* m);
//     ~softWriteLock();
//     /// Has a write lock been acquired?  Returns true or false to indicate
//     /// yes or no.
//     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

// /// Release the read/write lock.
// 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

// /// Gain read access.  It blocks when waiting to acquire the read lock.
// 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

// /// Gain write access.  It blocks when waiting to acquire the write lock.
// 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