文件映射操作类

已于 2023-12-20 21:51:01 修改
阅读量42 收藏
点赞数
分类专栏： 分布式文件存储引擎 文章标签： c++ 算法 开发语言
于 2023-12-20 21:44:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/VJOEE/article/details/135117669
版权

头文件

MMapFileOperation 类继承自 FileOperation 类，通过继承，子类可以复用基类的文件操作功能。

可以更方便地进行文件的内存映射操作，提供了一套简洁的接口，同时充分利用了继承和组合的思想，重写了父类文件操作类的读写操作，专门用于在内存映射时的读写。

mmap_file_op.h

#ifndef AIRWAVE_LARGEFILE_MMAPFILE_OP_H_
#define AIRWAVE_LARGEFILE_MMAPFILE_OP_H_

#include"common.h"
#include"mmap_file.h"
#include"file_op.h"

namespace Airwave
{
    namespace largefile
    {
        class MMapFileOperation : public FileOperation
        {
        public:
            MMapFileOperation(const std::string& filename, const int open_flags = O_RDWR | O_LARGEFILE | O_CREAT)
                :FileOperation(filename,open_flags),mmap_file_(NULL),is_mmapped_(false)
            {
                //空函数体
            }

            ~MMapFileOperation()
            {
                if (mmap_file_ != NULL)
                {
                    delete mmap_file_;
                    mmap_file_ = NULL;
                }
            }

            int mmap_file(const MMapOption& mmap_option);                                        //将文件映射到内存中,提供映射的参数
            int munmap_file();                                                                   //解除映射

            int pread_file(char* buf,const int32_t size,const int64_t offset);                  //从文件中指定偏移位置读取数据
            int pwrite_file(const char* buf,const int32_t size,const int64_t offset);           //在文件的指定偏移位置写入数据

            void* get_map_data() const;                                                        //获取映射的数据
            int flush_file();                                                                    //把文件立即写入磁盘

        private:
            MMapFile* mmap_file_;               //创建文件映射操作对象
            bool is_mmapped_;                   //是否映射标志
        };
    }





}


#endif // !Airwave_LARGEFILE_MMAPFILE_OP_H_

mmap_file_op.cpp

#include"mmap_file_op.h"
#include"common.h"

static int debug = 1;

namespace Airwave
{
    namespace largefile
    {
        //内存映射
        int MMapFileOperation::mmap_file(const MMapOption& mmap_option)
        {
            if(mmap_option.max_mmap_size_ < mmap_option.first_mmap_size_)       //确保最大映射大于首次映射
            {
                return TFS_ERROR;
            }

            if(mmap_option.max_mmap_size_ <= 0)         //确保最大映射大于0
            {
                return TFS_ERROR;
            }

            int fd = check_file();                  //检查文件是否打开
            if(fd < 0)
            {
                fprintf(stderr, "MMapFileOperation::mmap_file - check_file() failed!");
                return TFS_ERROR;
            }

            if(!is_mmapped_)                         //如果还没有映射
            {
                if(mmap_file_)
                {
                    delete mmap_file_;
                    mmap_file_ = NULL;
                }
                mmap_file_ = new MMapFile(mmap_option, fd);        //创建文件映射操作对象
                is_mmapped_ = mmap_file_->map_file(true);                      //将文件映射到内存，同时设置访问权限
            }

            if (is_mmapped_)
            {
                return TFS_SUCCESS;
            }
            else
            {
                return TFS_ERROR;
            }
        }

        //解除映射
        int MMapFileOperation::munmap_file()
        {
            if(is_mmapped_ && mmap_file_!=NULL)
            {
                delete mmap_file_;
                mmap_file_ = NULL;
                is_mmapped_ = false;
            }
            return TFS_SUCCESS;
        }

        void* MMapFileOperation::get_map_data() const
        {
            if(is_mmapped_)
            {
                return mmap_file_->get_data();
            }
            return NULL;
        }

        //
        int MMapFileOperation::pread_file(char* buf,const int32_t size,const int64_t offset)
        {
            //情况一，内存已经映射
            //如果读取的数据的偏移量大于等于文件在内存中映射的大小
            if(is_mmapped_ && (offset + size)>mmap_file_->get_size())
            {
                if(debug) 
                {
                    fprintf(stdout,"MMapFileOperation::pread_file , size : %d , offset : %ld , map file size : %d, need remap\n" , size, offset,mmap_file_->get_size());
                }
                mmap_file_->remap_file();
            }

            if(is_mmapped_ && (offset + size) <= mmap_file_->get_size())
            {
                memcpy(buf, (char*)mmap_file_->get_data() + offset,size);
                return TFS_SUCCESS;
            }


            //情况二，内存还没有映射,或者要读取的数据映射不全
            return FileOperation::pread_file(buf,size,offset);
        }

        int MMapFileOperation::pwrite_file(const char* buf ,const int32_t size,const int64_t offset)
        {
            //情况一，内存已经映射
            if(is_mmapped_ &&  (offset + size)>mmap_file_->get_size())
            {
                if(debug) 
                {
                    fprintf(stdout,"MMapFileOperation::pread_file , size : %d , offset : %ld , map file size : %d, need remap\n" , size, offset,mmap_file_->get_size());
                }
                mmap_file_->remap_file();
            }   

            if(is_mmapped_ && (offset + size) <= mmap_file_->get_size())
            {
                memcpy((char*)mmap_file_->get_data() + offset,buf,size);
                return TFS_SUCCESS;
            }

            //情况二，内存还没有进行映射，或者映射不全
            return FileOperation::pwrite_file(buf,size,offset);
        }

        int MMapFileOperation::flush_file()
        {
            if(is_mmapped_)
            {
                if(mmap_file_->sync_file())
                {
                    return TFS_SUCCESS;
                }
                else
                {
                    return TFS_ERROR;
                }
            }
            return FileOperation::flush_file();
        }
    }

}

测试 mmap_file_op_test.cpp

#include"common.h"
#include"mmap_file_op.h"
#include<iostream>

using namespace Airwave;
using namespace std;

const static largefile::MMapOption mmap_option = { 10240000, 4096, 4096 };//内存映射参数：最大映射大小、首次映射大小和每次映射增加的大小

int main(void)
{
    int ret = 0;

    const char* filename = "mmap_file_op.txt";
    largefile::MMapFileOperation* mmfo  = new largefile::MMapFileOperation(filename);

    int fd = mmfo->open_file();
    if (fd < 0)
    {
        fprintf(stderr, "open file %s failed. reason : %s\n",filename, strerror(-fd));
        exit(-1);
    }

    ret = mmfo->mmap_file(mmap_option);
    if(ret == largefile::TFS_ERROR)
    {
        fprintf(stderr,"mmap_file failed. reason : %s\n",strerror(errno));
        mmfo->close_file();
        exit(-2);
    }

    char buffer[128 + 1];
    memset(buffer,'6',128);

    ret = mmfo->pwrite_file(buffer,128,8);
    if (ret < 0)
    {
        if(ret == largefile::EIXT_DISK_OPER_INCOMPLETE)
        {
            fprintf(stderr, "pwrite_file %s failed. reason : %s\n",filename, strerror(-ret));
        }
        else
        {
            fprintf(stderr, "pwrite_file %s failed. reason : %s\n",filename, strerror(-ret));
        }
    }
    else
    {
        printf("write file %s success.\n",filename);
    }


       //第一次读取
    memset(buffer, 0, 128);
    ret = mmfo->pread_file(buffer, 128, 8);

    if (ret < 0)
    {
       if(ret == largefile::EIXT_DISK_OPER_INCOMPLETE)
        {
            fprintf(stderr, "read file %s failed. reason : %s\n",filename, strerror(-ret));
        }
        else
        {
            fprintf(stderr, "read file %s failed. reason : %s\n",filename, strerror(-ret));
        }
    }
    else
    {
        buffer[129] = '\0';
        printf("read file %s success. content : %s\n",filename, buffer);
    }

    ret = mmfo->flush_file();
    if(ret == largefile::TFS_ERROR)
    {
        fprintf(stderr,"flush file failed . reason : %s\n",strerror(errno));
    }

    mmfo->munmap_file();

    mmfo->close_file();

    return 0;
}

修改写入的偏移量，测试是否会自动扩容

可以看到超出映射的空间后，文件自动进行映射扩容

Airwave1
关注
专栏目录
SQL映射文件详解
m0_59323626的博客
08-20 2419
SQL映射文件详解
C\C++\QT文件操作：流读写\内存映射
Rainbow
01-04 3860
文件操作
XML 映射文件
csdn1428208016的博客
12-25 7066
XML 映射文件 MyBatis 的真正强大在于它的映射语句，也是它的魔力所在。由于它的异常强大，映射器的 XML 文件就显得相对简单。MyBatis 就是针对 SQL 构建的，并且比普通的方法做的更好。 SQL 映射文件有很少的几个顶级元素（按照它们应该被定义的顺序）： cache – 给定命名空间的缓存配置。 cache-ref – 其他命名空间缓存配置的引用。 resultMap – 是最...
2.1 PE结构：文件映射进内存
CSDN
09-04 4386
PE结构是`Windows`系统下最常用的可执行文件格式，理解PE文件格式不仅可以理解操作系统的加载流程，还可以更好的理解操作系统对进程和内存相关的管理知识，在任何一款操作系统中，可执行程序在被装入内存之前都是以文件的形式存放在磁盘中的，在早期DOS操作系统中，是以COM文件的格式存储的，该文件格式限制了只能使用代码段，堆栈寻址也被限制在了64KB的段中，由于PC芯片的快速发展这种文件格式极大的制约了软件的发展。
Mybatis映射配置文件
cyyyff的博客
05-20 1573
Mybatis映射配置文件
MyBatis_映射文件详解
斗鹰的技术专栏
01-31 5069
上次说到了MyBatis的全局配置文件，今天就看看MyBatis的映射文件。MyBatis真正强大在乎它的映射文件。由于它的异常强大，映射器的XML文件就显得相对简单。如果拿它跟具有相同功能的JDBC代码进行对比，会发现省掉了近95%的代码。包括了MyBatis来完成CRUD操作以及自动映射和自定义映射。
MyBatis官方文档-XML 映射文件
ThinkWon的博客
09-16 6528
最近更新: 15 七月 2019|版本: 3.5.2 XML 映射文件 MyBatis 的真正强大在于它的映射语句，这是它的魔力所在。由于它的异常强大，映射器的 XML 文件就显得相对简单。如果拿它跟具有相同功能的 JDBC 代码进行对比，你会立即发现省掉了将近 95% 的代码。MyBatis 为聚焦于 SQL 而构建，以尽可能地为你减少麻烦。 SQL 映射文件只有很少的几个顶级元素（按照应被定义...
内存映射文件的应用
bajianxiaofendui的博客
06-08 6909
内存映射文件的应用一，操作系统加载EXE和DLL二，读写大文件三，进程间通信      内存映射文件是windows开发下常用的一种技术，既可以用来读写磁盘上的大文件，也可以用来实现进程间的通信，本文主要对内存映射的几大用途做一个简述。 一，操作系统加载EXE和DLL      当一个应用程序启动时...
Mybatis映射文件规则
梦想也许遥不可及，但重要的是追梦的过程，用博客记录自己的成长，记录自己一步一步向上攀登的印记
03-30 3308
在说明映射文件规则之前，先来回顾一下ORM相关概念。 1.ORM概念 ORM(Object Relationship Mapping)对象关系映射 对象：Java的实体类对象 关系：关系型数据库 映射：二者之间的对应关系 字段名和属性名要一一对应才可以，它们的名字要相同，底层调用的是反射机制 Java概念 数据库概念 属性 列，字段 对象 记录 类 表 2.映射文件命名规则 表对应的实体类的类名+Mapper.xml 举例：假如数据库的表的名字是t_user,它对应的实体类是Us
MyBatis映射文件Mapper.xml详解
共勉
04-10 6389
映射文件是 MyBatis 框架中十分重要的文件 可以说， MyBatis 框架的强大之处就体现在映射文件的编写上。在映射文件中，<mapper>元素是映射文件的根元素，其他元素都是它的子元素。 Select元素 <select>元素用来映射查询语句，它可以帮助我们从数据库中读取出数据。如下代码所示： <select id="findCustomerById" pa...
文件映射封装类
04-16
总之，"文件映射封装类"是为了简化跨平台的文件映射操作而设计的，它将复杂的系统调用封装在易于使用的类中，使得开发者可以更高效、安全地利用文件映射功能。通过理解mymmapw.cpp、mymmapu.cpp、mymmapu.h和mymmapw...
映射文件操作封装类
10-09
在Windows操作系统中，映射文件（Memory-Mapped File）是一种将磁盘文件映射到进程地址空间的技术，使得文件内容可以直接通过内存访问，从而提高了文件操作的速度和效率。在Linux系统中，这种技术通常被称为内存映射...
C++ 可以解决64位程序调用32位库、双向信道跨进程间通信的文件映射处理类源码
09-11
1初始化文件映射对象 2同步 3获取文件映射对象的映射视图 4释放文件映射对象的映射视图 5释放文件映射对象 源码包含了封装的功能模块类以及测试类， 全部源码都可以用VS2020编译通过，请放心使用！ 友情提示，为了...
ZMemoryFile.rar_C 内存映射_内存映射_封装类_文件到内存_文件映射封装
09-23
4. **同步操作**：由于内存映射文件可能涉及多线程环境，封装类可能包含同步机制，如互斥锁，确保并发安全。 5. **错误处理**：封装异常处理，当映射或读写文件时遇到问题，抛出异常或返回错误代码。 `...
大文件读写内存映射.rar
05-18
在Qt中，`QFile`类提供了一种简单的方式进行文件操作，但若要进行大文件的内存映射，我们需要使用`QMap`和`QMemoryMappedBuffer`。`QMap`用于创建内存映射的缓冲区，而`QMemoryMappedBuffer`则用于管理这个映射的...
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1231
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
【C语言系统编程】【第三部分：网络编程】3.2 数据传输和协议
10-03 1560
在进行网络编程时，有时需要设计并实现自定义协议，以满足特定应用的需求。自定义协议设计需要考虑到数据的传输、安全、效率等多方面因素。清晰性：协议应具有清晰的语法和语义，使开发者能快速理解和实现。扩展性：协议应允许未来的功能扩展，而不破坏现有功能。安全性：数据传输过程中应考虑加密和校验，以保证数据不被篡改。高效性：应尽可能减少网络带宽占用，提升数据传输效率。容错性：协议应能处理各种网络异常情况，如数据丢失、重复和延迟。
使用socket编程来实现一个简单的C/S模型（TCP协议）
caiji0169的博客
10-02 1732
下图是基于TCP协议的客户端/服务器程序的一般流程：服务器调用socket()、bind()、listen()完成初始化后，调用accept()阻塞等待，处于监听端口的状态，客户端调用socket()初始化后，调用connect()发出SYN段并阻塞等待服务器应答，服务器应答一个SYN-ACK段，客户端收到后从connect()返回，同时应答一个ACK段，服务器收到后从accept()返回。数据传输的过程：建立连接后，TCP协议提供全双工的通信服务，但是一般的客户端/服务器程序的流程是由客户端主动发起请求，
windows C++-创建数据流代理(三)
最新发布
苏洛的博客
10-08 295
控制流指的是程序中操作的执行顺序。 控制流是通过使用条件语句、循环等控制结构调节的。 此外，数据流指的是一种编程模型，在这种模型中，只有当所有需要的数据都可用时，才会进行计算。 数据流编程模型与消息传递这一概念相关，其中程序的独立组件通过发送消息相互通信。 异步代理同时支持控制流和数据流编程模型。 尽管控制流模型适用于许多情况，但数据流模型也适用于其他一些情况，例如，当代理接收数据并执行基于该数据的有效负载的操作时。
MyBatis入门与映射文件详解
MyBatis支持对数据库的CRUD操作，包括Select、Insert、Update和Delete，既可以基于普通的Java类，也可以基于接口实现。 **知识点三：MyBatis关联映射** MyBatis的关联映射用于处理对象间的复杂关系，包括一对一和一...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值