inputHandlerGpfs.cpp

Go to the documentation of this file.

#include "inputHandlerGpfs.h"
#include "block.h"
#include "copyRequestTypes.h"
#include "ewmscp.h"
#include "timer.h"
 
#include <fcntl.h>
#include <throwcall.h>
#include <unistd.h>
 
#include <memory>
 
namespace inputHandler {
    decltype(Gpfs::factory) Gpfs::factory("Gpfs");
    std::unique_ptr<base::reader> Gpfs::newReader(const std::string& aPath,
            copyRequest::stateType &state,
            const genericStat& inititalStat) {
        return std::unique_ptr<base::reader>(new readerGpfs(aPath,
                                             state,
                                             inititalStat));
    }
    static options::single<bool> useRange('\0', "gpfsInUseRange", "use range hint in gpfs input", false);
    static options::single<bool> freeRange('\0', "gpfsInFreeRange", "use range free in gpfs input", false);
    static options::single<bool> doClearCache('\0', "gpfsInClearCache", "clear cache in gpfs input", false);
    
    
    Gpfs::readerGpfs::readerGpfs(const std::string& aPath,
                                 copyRequest::stateType &state,
                                 const genericStat&inititalStat):
        posixFileIoCommon(aPath),
        gpfsIoCommon(aPath),
        posixFile::readerPosixFile(aPath, state, inititalStat) {
        if (fd != -1 && useRange) { // we have an open file
            gpfs_fcntl_handler fcntl;
            auto& range = fcntl.buffer.add<gpfsAccessRange_t>(GPFS_ACCESS_RANGE);
            range.start = 0;
            range.length = inititalStat.size;
            range.isWrite = 0;
            timerInst(gpfsAccessRange);
            fcntl.call(fd, path);
        }
    }
    Gpfs::readerGpfs::~readerGpfs() {
        if (fd != -1 && doClearCache) { // we have an open file
            gpfs_fcntl_handler fcntl;
            fcntl.buffer.add<gpfsClearFileCache_t>(GPFS_CLEAR_FILE_CACHE);
            timerInst(gpfsClearFileCache);
            fcntl.call(fd, path);
        }
    }
 
    std::unique_ptr<acl::list> Gpfs::getAclData(const std::string& path) {
        gpfs_acl_handler aclHandler;
        aclHandler.get(-1, path);
        return gpfsIoCommon::aclFromGpfs(aclHandler, path);
    };
 
    bool Gpfs::readerGpfs::readBlock(block &b) {
        auto lastblock = readerPosixFile::readBlock(b);
        // we read sequentially anyway so keep tracking simple
        leastRecentlyAccessedBlock = b.offset();
        if (freeRange) {
            releaseUsedBlocks(b.max_size());
        }
        return lastblock;
    };
    void Gpfs::readerGpfs::readBlockP(block& b, size_t bytesToRead, off_t offset) {
        readerPosixFile::readBlockP(b, bytesToRead, offset);
        if (freeRange) {
            handleParallelUsedBlocks(b.max_size(), offset);
        }
    };
 
} //end namespace inputHandler