淘宝分布式文件系统引擎（五） 内存映射实战

已于 2023-02-02 11:03:36 修改
阅读量486 收藏 2
点赞数 3
分类专栏： 淘宝分布式文件系统核心存储引擎 文章标签： c++ linux 内存映射
于 2021-01-14 13:36:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jacksqh/article/details/111463393
版权

文章目录

完整的源码在下面这个链接哟
github源码

在这感谢我们的小马哥，天天带我们玩些企业开发中的一些我没见过的操作，接下来是关于内存映射这一模块的实战了（这里的的代码是在Linux环镜中运行，都是可以直接运行的哟），搞起！！！！！

关于头文件的一些注意事项

首先我们要知道为了避免重复包含头文件而引发的一些不必要的错误我们要利用#ifndef和#endif来实现避免重复包含 
#ifndef QINIU_LARGEFILE_MMAPFILE_H_
#define QINIU_LARGEFILE_MMAPFILE_H_
......//中间的代码块
#endif
而对于我们常用的一些常规头文件我们可以放在一个公共头文件"common.h"中 
#ifndef _COMMON_H_INCLUDE_
#define _COMMON_H_INCLUDE_


#include<string>
#include<iostream>
#include<sys/types.h> 
#include<sys/stat.h> 
#include<fcntl.h>
#include<string.h>
#include<stdint.h>
#include<unistd.h>
#include<errno.h>
#include<stdio.h>
#include<sys/mman.h> 
#include<stdlib.h>
#include<inttypes.h>

#endif /*_COMMON_H_INCLUDE_*/
如果我们在开发过程中要注意层次结构，让我们的代码看起来层次分明，对于这样的目的我这里采用的是利用命名空间来使我们的整个层次非常分明 
namespace qiniu
{
	namespace largefile
	{
		.....//在这定义各种类
	}
}

内存映射操作头文件

在这开始我就不写什么了，避免整个博客篇幅太长，很多注释都在代码中了 
#ifndef QINIU_LARGEFILE_MMAPFILE_H_
#define QINIU_LARGEFILE_MMAPFILE_H_
#include"common.h"
namespace qiniu
{
	namespace largefile
	{
		//调整文件映射的一些选项（根据实际情况自己可以去设置）
		struct MMapOption
		{
			int32_t max_mmap_size_;   //最大映射大小,3M
			int32_t first_mmap_size_; //第一次设置的映射大小,4K
			int32_t per_mmap_size_;   //每次追加多少,4K
		};
		class MMapFile
		{
			public:
			 MMapFile();
			 //explici关键字避免该构造函数隐式转换
			 explicit MMapFile(const int fd);
			 MMapFile(const MMapOption& mmap_option,const int fd);
				
			 ~MMapFile();
			 bool sync_file(); //同步内存数据到文件
			 bool map_file(const bool write=false);  //真正的映射同时设置一些权限
			 
			 void* get_data()const;    //获取映射到内存数据的首地址
			 int32_t get_size()const;  //获取映射数据大小
			 
			 bool munmap_file();  //解除映射
			 bool remap_file();  //重新映射
			  
			private:
			 bool ensure_file_size(const int32_t size);  //调整文件大小
			
			private:
			 int32_t size_;  //现在已经映射内存的大小
			 int fd_;
			 void* data_;	 //映射数据的首地址
			 
			 struct MMapOption mmap_file_option_;
		};
	}
	
}

#endif  /*QINIU_LARGEFILE_MMAPFILE_H_*/

内存映射之cpp源码实现

#include"mmap_file.h"
#include<stdio.h>
static int debug=1;  //调试开关：0为不打开，1为打开


namespace qiniu
{
	namespace largefile
	{
		//初始化列表
		MMapFile::MMapFile():size_(0),fd_(-1),data_(NULL){
		}
		MMapFile::MMapFile(const int fd):size_(0),fd_(fd),data_(NULL){
		}
		
		MMapFile::MMapFile(const MMapOption& mmap_option,const int fd):size_(0),fd_(fd),data_(NULL){
			mmap_file_option_.max_mmap_size_=mmap_option.max_mmap_size_;
			mmap_file_option_.first_mmap_size_=mmap_option.first_mmap_size_;
			mmap_file_option_.per_mmap_size_=mmap_option.per_mmap_size_;
		}
		
		MMapFile::~MMapFile(){
			if(data_){
				if(debug)printf("mmap_file destruct fd:%d, data:%p, mmap size:%d\n",fd_,data_,size_);
				msync(data_,size_,MS_SYNC);  //同步操作
				munmap(data_,size_);
				
				size_=0;
				data_=NULL;
				fd_=-1;
				
				mmap_file_option_.max_mmap_size_= 0;
				mmap_file_option_.first_mmap_size_= 0;
				mmap_file_option_.per_mmap_size_= 0;
			}
		}
		
		//同步文件
		bool MMapFile::sync_file(){
			if(data_!=NULL&&size_>0){
				if(msync(data_,size_,MS_ASYNC)==0)return true;
				return false;
			}
			return true;
		}
		
		//具体文件映射
		bool MMapFile::map_file(const bool write){
			int flags=PROT_READ;
			if(write){
				flags|=PROT_WRITE;
			}
			
			if(fd_<0){
				return false;
			}
			
			//如果最大映射内存大小为0 return false;
			if(0==mmap_file_option_.max_mmap_size_){
				return false;
			}
			
			if(size_<mmap_file_option_.max_mmap_size_){
				//分配第一次可以分配的大小(这个是根据自己的需要进行操作，并不一定要这样)
				size_=mmap_file_option_.first_mmap_size_;
			}else{
				size_=mmap_file_option_.max_mmap_size_;
			}
			
			if(!ensure_file_size(size_)){
				fprintf(stderr,"ensure file size faild in map_file,size:%d\n",size_);
			}
			
			//void *mmap(void *addr, size_t length, int prot, int flags,int fd, off_t offset);
			data_=mmap(0,size_,flags,MAP_SHARED,fd_,0);
			
			if(data_==MAP_FAILED){
				//定向到控制台,获取出错原因
				fprintf(stderr,"map file faild:%s",strerror(errno));
				size_=0;
				fd_=-1;
				data_=NULL;
				return false;
			}
			if(debug){
				printf("mmap file successed ,fd: %d ,mapped size: %d ,data: %p \n",fd_,size_,data_);
			}
			return true;
		}
		
		//获取映射到内存数据的首地址
		void* MMapFile::get_data()const{  
			return data_;
		}
		
		//获取映射数据大小
		int32_t MMapFile::get_size()const{  
			return size_;
		}
		
		//解除映射
		bool MMapFile::munmap_file(){
			if(munmap(data_,size_)==0){
				return true;
			}else{
				return false;
			}
		}
		
		//调整文件大小
		bool MMapFile::ensure_file_size(const int32_t size){
			//存放文件的状态信息
			struct stat s;
			//fstat(int filedes,struct stat *s);
			if(fstat(fd_,&s)<0){
				fprintf(stderr,"fstat error,error desc:%s\n",strerror(errno));
				return false;
			}
			
			//如果文件的大小比我们内存中映射的小,进行调整
			if(s.st_size<size){
				if(ftruncate(fd_,size)<0){
					fprintf(stderr,"ftruncate error,size:%d ,error desc:%s\n",size_,strerror(errno));
					return false;
				}
			}
			//fprintf(stderr,"ftruncate success,size:%d\n",s.st_size);
			return true;
		}
		
		//追加映射
		bool MMapFile::remap_file(){
			if(fd_<0||data_==NULL){
				fprintf(stderr,"mremap notmapped yet\n");
				return false;
			}
			if(size_==mmap_file_option_.max_mmap_size_){
				fprintf(stderr,"already mapped max size,now size:%d max size:%d",size_,mmap_file_option_.max_mmap_size_);
				return false;
			}
			int32_t new_size=size_+mmap_file_option_.per_mmap_size_;
			if(new_size>mmap_file_option_.max_mmap_size_){
				new_size=mmap_file_option_.max_mmap_size_;
			}
			
			//同步文件大小
			if(!ensure_file_size(new_size)){
				fprintf(stderr,"ensure file size faild in map_file,size:%d\n",new_size);
				return false;
			}
			if(debug)printf("mremap start fd:%d,new size:%d, old data:%p\n",fd_,new_size,data_);
			
			void*new_map_data=mremap(data_,size_,new_size,MREMAP_MAYMOVE);
			if(MAP_FAILED==new_map_data){//如果映射失败
				fprintf(stderr,"mremap failed,fd:%d  new size:%d,error desc:%s\n",fd_,new_size,strerror(errno));
				return false;
			}else{
				if(debug)printf("mremap success fd:%d,new size:%d, old data:%p\n",fd_,new_size,new_map_data);
			}
			
			size_=new_size;
			data_=new_map_data;
			return true;
		}
		
	}
}

主方法

#include"mmap_file.h"
#include"common.h"
using namespace std;
using namespace qiniu;
static const mode_t OPEN_MODE=0644;//用户本人6:110可读可写，同组其他成员的权限4:100可读，其他成员4:100可读，其他成员4
const static largefile::MMapOption mmap_option={10240000,4096,4096};

int open_file(string file_name,int open_flags){
	int fd=open(file_name.c_str(),open_flags,OPEN_MODE);//打开文件
	if(fd<0){
		return -errno;//error strerror(error)
	}
}


int main(){
	const char*filename="./mapfile_test.txt";
	//1.打开或者创建文件，取句柄，open函数
	int fd=open(filename,O_RDWR|O_CREAT|O_LARGEFILE);
	//int fd=open(filename,O_RDWR|O_LARGEFILE);
	if(fd<0){
		fprintf(stderr,"open file failed filename:%s  error reason:%s\n",filename,strerror(-fd));//相对于是strerror(errno)
		return -1;
	}
	
	largefile::MMapFile*map_file=new largefile::MMapFile(mmap_option,fd);
	//映射搞起
	bool is_mapped=map_file->map_file(true);
	//防御性编程
	if(is_mapped){
		map_file->remap_file();
		printf("map_file size:%d  and  data:%p\n",map_file->get_size(),map_file->get_data());
		memset(map_file->get_data(),'9',map_file->get_size());//写入内存中
		
		//同步文件
		map_file->sync_file();
		
		//解除映射
		map_file->munmap_file();
	}else{
		fprintf(stderr,"map file faild\n");
	}
	
	close(fd);
	
	return 0;
}

运行结果

编译成功，并运行
编译成功
成功创建了mapfile_test.txt文件
在这里插入图片描述

mapfile_test.txt文件成功进行读写了
在这里插入图片描述

这个部分结束了，这个是可以直接在linux下直接运行的，如果有兴趣可以试试，希望这个对你有帮助，谢谢(*^_^*)
CAccept
关注
专栏目录
第6章 分布式文件存储
Eclipse_2019的博客
08-20 465
本文介绍了Mini商城系统的分布式文件存储系统的技术方案选择以及MinIO的接口实现。
淘宝分布式文件系统引擎（四）哈希链表结构以及内存映射
Jacksqh的博客
12-20 435
文章目录哈希链表结构内存映射应用场景进程间通信 - 文件映射原理（mmap函数）文件映射 - mmap实现内存映射之msync内存映射之mremap 哈希链表结构 哈希表 - 散列表 它是基于快速存取的角度设计的，也是一种典型的“空间换时间”的做法 关键点： 键(key)： 文件的编号 如， 1 、 5 、 19 。 。 。 值(value)： 文件的索引信息（包含 文件大小、位置） 索引: 数组的下标(0,1,2,3,4)
TFS淘宝分布式文件核心存储引擎源码架构剖析实现
weixin_45825875的博客
05-02 2458
相关背景介绍 相关设计技术介绍 文件系统接口 文件系统是一种把数据组织成文件和目录方式，提供基于文件的存取接口，并通过权限控制。 扇区 磁盘读写的最小单位就是扇区，一般每个扇区是 512 字节(相当于0.5KB); 文件的基本单位块 － 文件存取的最小单位。"块"的大小，最常见的是4KB，即连续八个 sector组成一个 block。 在 Linux 系统中可以用 stat 查看文件相关信息 文件结构 目录项区:存放目录下文件的列表信息 文件数据: 存放文件数据 inode区:（inode table）
淘宝分布式文件系统引擎（一） 文件系统基本概念
Jacksqh的博客
12-11 821
前言 因为最近在学习以及手写淘宝分布式文件系统引擎，在这记录一下学习的整个过程，也把淘宝分布式文件系统引擎这一内容做一个模块持续更新直到把这个内容完成，在这过程中会涉及到文件系统，存储，哈希映射等等一些概念，希望这些总结也能对你有所帮助，同样的如果文中有出现一些错误或者是有不同理解的地方也欢迎提出来，谢谢！！！ 文件系统的基本概念 文件系统: 是一种把数据组织成文件和目录的一种存储方式，提供一些接口对于文件进行各种操作，还有对于文件权限进行控制访问，对于程序员来说就可以简单地把它看成提供各种接口的一种东西
内存映射文件原理探索
热门推荐
我可能长大了
09-17 5万+
首先，“映射”这个词，就和数学课上说的“一一映射”是一个意思，就是建立一种一一对应关系，在这里主要是只硬盘上文件的位置与进程逻辑地址空间中一块大小相同的区域之间的一一对应，如图1中过程1所示。这种对应关系纯属是逻辑上的概念，物理上是不存在的，原因是进程的逻辑地址空间本身就是不存在的。在内存映射的过程中，并没有实际的数据拷贝，文件没有被载入内存，只是逻辑上被放入了内存，具体到代码，就是建立并初始化了相关的数据结构（struct address_space），这个过程有系统调用mmap()实现，所以建立内存映射
淘宝分布式文件系统核心储存引擎学习总结
weixin_45738899的博客
03-03 4588
淘宝分布式文件核心储存引擎架构总结——TFS系统1.内存映射类1.主要功能2.主要方法2.文件操作类1.主要功能2.基本方法 1.内存映射类 内存映射类——MMapFile 1.主要功能 实现内存映射的相关操作，封装内存映射相关函数。 2.主要方法 执行内存映射——map_file() 重新执行内存映射(常用来扩容)——remap_file() 得到内存映射首地址——get_data() 得到内存映射大小——get_size() 解除内存映射——munmap_file() 将内存映射的内容同步到文件——e
分布式文件系统引擎
学习记录
04-01 798
TFS 分布式文件系统引擎
大规模分布式存储系统 - 读书笔记
Syntactic Sugar
04-19 2422
文章目录大规模分布式存储系统（原理解析与架构实战OceanBase）第1章 概述1.1 分布式存储概述1.2 分布式存储分类第一篇 基础篇第2章 单机存储系统2.1 硬件基础2.1.1 CPU架构2.1.2 IO总线2.1.3 网络拓扑2.1.4 性能参数2.1.5 存储层次架构2.2 单机存储引擎2.2.1 哈希存储引擎2.2.2 B树存储引擎2.2.3 LSM树存储引擎2.3 数据模型2.3.1 文件模型2.3.2 关系模型2.3.3 键值模型2.3.4 SQL与NoSQL2.4 事务与并发控制2.4.
大规模分布式存储系统原理解析与架构实战
fishmai的专栏
11-25 8295
后几张是讲一些具体产品的内容，对于每一个产品，都需要确实的使用和经验，以后需要的时候再研究不迟，技术永远在使用中进步更大。 以前对存储尤其是分布式存储的整体知识体系不是太清楚，只是片段式的知道一些理论，通过此书的学习，对分布式存储的原理将豁然开朗，不管是理论的还是后面几章讲述的具体产品，都能做到知其然知其所以然。另外，书中对Paxos协议也进行了深入介绍，理解此协议对时下流行的去中心化将有“
【搜索引擎原理与实战】全文搜索的原理与代码实例讲解
程序员光剑
07-30 474
在当今信息爆炸的时代，快速准确地从海量数据中检索所需信息变得至关重要。全文搜索技术应运而生，成为现代搜索引擎的核心组成部分。无论是Google、百度这样的网络搜索巨头，还是企业内部的文档管理系统，全文搜索都扮演着不可或缺的角色。本文将深入探讨全文搜索的原理，并通过具体的代码实例，为读者展示如何实现一个基础的全文搜索引擎。全文搜索不同于传统的数据库检索，它能够对文本内容进行全面分析和索引，支持复杂的查询需求，如模糊匹配、多字段组合查询等。
ELK日志分析平台——elasticsearch分布式部署
S_K15的博客
08-13 768
elasticsearch实战
【大数据 OLAP 技术新书推荐】 字节跳动阿里巴巴大厂资深架构师程序员多年实践经验总结《ClickHouse入门、实战与进阶》ClickHouse领域集大成之作，入门标准参考书日常工作案头必备手册
程序员光剑
06-25 1万+
本书是ClickHouse领域的集大成之作，从基础知识、实现原理、项目实战、扩展应用4个维度全面展开，表述简练清晰、案例丰富实用，既可以作为入门的标准参考书，又适合作为案头速查手册。书中内容是作者在阿里巴巴、字节跳动多年实战经验的总结，得到了字节跳动和阿里巴巴9位大数据专家的高度评价。全书共10章，主要内容如下：第1~3章整体介绍ClickHouse概念、特性、应用场景、技术生态、快速入门和基础数据类型等基础内容，目的是从本质上揭开ClickHouse高性能背后的秘密，帮助读者快速上手实践。
Tachyon---基于内存的分布式存储系统
行者小朱的博客
08-19 5617
Tachyon是一个以内存为核心的开源分布式存储系统，也是目前发展最迅速的开源大数据项目之一。Tachyon为不同的大数据计算框架（如Apache Spark，Hadoop MapReduce, Apache Flink等）提供可靠的内存级的数据共享服务。此外，Tachyon还能够整合众多现有的存储系统（如Amazon S3, Apache HDFS, RedHat GlusterFS, Op
分布式持久内存文件系统Octopus（ATC-17 ）分析（一）
Meditator_hkx的博客
01-25 4203
清华课题 Octopus 源码分析一 前言 论文摘要 设计框架 源码分析 清华课题 Octopus 源码分析（一） 前言 由于项目工作的需要，我们团队阅读了清华在文件系统方面的一个比较新颖的工作：Octopus。Octopus是一个基于持久内存 NVM 和远程直接内存访问 RDMA 技术的分布式内存文件系统。清华的陆游游老师现已将代码开源，可 点击此处 阅读。 这一工作
C语言 12 函数
天河有尽后为涯，星海无边前作岸。
09-13 696
程序的入口点就是main函数，只需要将程序代码编写到主函数中就可以运行了，不过这个函数只是由我们来定义，而不是我们来调用。当然，除了主函数之外，一直在使用的printf那么，函数的具体定义是什么呢？函数是完成特定任务的独立程序代码单元。每次要做这个任务时，都要完完整整地将任务的每一行代码都写下来，如果程序中多处都需要执行这个任务，每个地方都完整地写一遍，实在是太臃肿了，有没有一种更好的办法能优化代码呢？
CF C. Nikita and LCM
最新发布
qq_74190237的博客
09-13 154
思维题.首先先对数组排序,考虑一种特殊情况,那就是如果数组最大值不能被其他数整除,这代表什么?代表其他数里面有某个质因子,最大值里面没有或者数量不管,所有最小公倍数都会大于最大值.那么其他情况的话,就可以确定所有的数都是最大数的因子,那么形成的最小公倍数也一定是最大数的因子,那么就可以枚举一下最大数的因子,就可以了.给长度为n的数组,求出最长的特殊子数组,如果子数组的最小公倍数不在原数组中,那么就是特殊的.
【c++23种设计模式概述】
m0_45463480的博客
09-09 789
c++23种设计模式概述。
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值