O_DIRECT方式读取文件示例

#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/time.h>
#include <unistd.h>
#include <glog/logging.h>
#include <gflags/gflags.h>

// 读文件类
class CFileReader
{
public:
    CFileReader()
        : _buffer(NULL)
    {
    }

    ~CFileReader()
    {
        free(_buffer);
    }

    bool open(const char* filepath)
    {
        // 以O_DIRECT方式打开文件
        int fd = ::open(filepath, O_RDONLY | O_DIRECT);
        if (-1 == fd)
        {
            LOG(ERROR) << "open " << filepath << " error: " << strerror(errno);
            return false;
        }

        // 取得文件大小，以便一次性将文件读取出来
        struct stat st;
        if (-1 == fstat(fd, &st))
        {
            LOG(ERROR) << "stat " << filepath << " error: " << strerror(errno);
            close(fd);
            return false;
        }

        // 分配足以容纳整个文件的Buffer
        // 由于以O_DIRECT方式读取，所以需要按页对齐
        size_t size = st.st_size + (getpagesize() - st.st_size%getpagesize());
        posix_memalign((void**)&_buffer, getpagesize(), size);
        if (NULL == _buffer)
        {
            LOG(ERROR) << "malloc failed";
            close(fd);
            return false;
        }

        // 将整个文件读取_buffer中
        int bytes_read = read(fd, _buffer, size);
        if (-1 == bytes_read)
        {
            LOG(ERROR) << "read " << filepath << " error: " << strerror(errno);
            close(fd);
            free(_buffer);
            _buffer = NULL;
            return false;
        }
        else if (bytes_read != size)
        {
            // 两组测试输出数据：
            // FileSize(212000000) => AlignSize(212000768) -> RealSize(212000000)
            // FileSize(2120000000) => AlignSize(2120003584) -> RealSize(2120000000)
            printf("FileSize(%d) => AlignSize(%d) -> RealSize(%d)\n", st.st_size, size, bytes_read);
        }

        return true;
    }

    // 从文件中读取一个节点数据
    // offset：偏移量
    // return：返回指向记录的指针
    template <class P>
    const P* get_record(uint64_t offset) const
    {
        return reinterpret_cast<P*>(_buffer + offset);
    }

    // 取得文件所有的记录
    template <class P>
    const P** get_all_record() const
    {
        return reinterpret_cast<P**>(_buffer);
    }

private:
    char* _buffer;
};

// 用于计时
class TimeWatcher
{
public:
    TimeWatcher(const std::string& tip)
        : _tip(tip)
    {
        struct timeval now;
        gettimeofday(&now, NULL);

        _now_msec = (now.tv_sec * 1000) + (now.tv_usec / 1000);
    }

    ~TimeWatcher()
    {
        struct timeval now;
        gettimeofday(&now, NULL);

        time_t cur_msec = (now.tv_sec * 1000) + (now.tv_usec / 1000);
        LOG(INFO) << _tip << " spend " << cur_msec - _now_msec << "ms";
    }

private:
    std::string _tip;
    time_t _now_msec;
};

struct User
{
    int32_t age;
    int32_t hight;
    int32_t weight;
    char bitmap[50*4];
};


// 用于生成测试文件
bool make_test_file(const char* filepath, int num_records)
{
    int fd = open(filepath, O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR);
    if (-1 == fd)
    {
        LOG(ERROR) << "open " << filepath << " error: " << strerror(errno);
        return false;
    }

    User user;
    TimeWatcher time_watcher("write");

    for (int i=0; i<num_records; ++i)
    {
        user.age = i;
        user.hight = i + i;
        user.weight = i * i;

        if (-1 == write(fd, &user, sizeof(user)))
        {
            LOG(ERROR) << "write " << filepath << " error: " << strerror(errno);
            close(fd);
            return false;
        }
    }

    close(fd);
    return true;
}

// 模拟随机读取
void random_read(const CFileReader& file_reader, int num_random)
{
    int *index = new int[num_random];

    for (int i=0; i<num_random; ++i)
    {
        srandom(time(NULL));
        index[i] = random() % num_random;
    }


    TimeWatcher time_watcher("randmon read");
    for (int i=0; i<num_random; ++i)
    {
        file_reader.get_record<struct User>(index[i]);
    }
}

// 执行测试
void test()
{
    int num_records1 = 1000000;
    int num_records2 = 10000000;
    std::string file1 = "./file_1000000";
    std::string file2 = "./file_10000000";

    if (make_test_file(file1.c_str(), 1000000)
         && make_test_file(file2.c_str(), 10000000))
    {
        printf("to read, press ENTER to continue ...\n");
        getchar();

        CFileReader file_reader1;

        {
            TimeWatcher time_watcher("open");
            if (!file_reader1.open(file1.c_str()))
            {
                return;
            }
        }

        random_read(file_reader1, 1000000);
        random_read(file_reader1, 3000000);

        CFileReader file_reader2;

        {
            TimeWatcher time_watcher("open");
            if (!file_reader2.open(file2.c_str()))
            {
                return;
            }
        }

        random_read(file_reader2, 1000000);
        random_read(file_reader2, 3000000);
    }
}

int main(int argc, char* argv[])
{
    test();
    return 0;
}