精华内容
下载资源
问答
  • 内存文件映射原理和简单应用

    千次阅读 2017-08-06 19:22:39
    参考博客:... ... 内存映射文件原理探究 硬盘上文件 的位置与进程 逻辑地址空间 中一块大小相同的区域之间的一一对应,这种对应关系纯属是逻辑上的概念,物理上是不存在的,原因是
    1. 参考博客:http://blog.csdn.net/haiross/article/details/46875211
    2. 参考博客:http://blog.csdn.net/mg0832058/article/details/5890688 内存映射文件原理探究
    3. 硬盘上文件 的位置与进程 逻辑地址空间 中一块大小相同的区域之间的一一对应,这种对应关系纯属是逻辑上的概念,物理上是不存在的,原因是进程的逻辑地址空间本身就是不存在的,在内存映射的过程中,并没有实际的数据拷贝,文件没有被载入内存,只是逻辑上被放入了内存,具体到代码,就是建立并初始化了相关的数据结构(struct address_space),这个过程有系统调用mmap()实现,所以建立内存映射的效率很高。mmap将一个文件或者其它对象映射进内存,mmap必须以PAGE_SIZE为单位进行映射,而内存也只能以页为单位进行映射,若要映射非PAGE_SIZE整数倍的地址范围,要先进行内存对齐,强行以PAGE_SIZE的倍数大小进行映射。
    4. mmap()会返回一个指针ptr,它指向进程逻辑地址空间中的一个地址,这样以后,进程无需再调用read或write对文件进行读写,而只需要通过ptr就能够操作文件。但是ptr所指向的是一个逻辑地址,要操作其中的数据,必须通过MMU(内存管理单元)将逻辑地址转换成物理地址,这个过程与内存映射无关。

      前面讲过,建立内存映射并没有实际拷贝数据,这时,MMU在地址映射表中是无法找到与ptr相对应的物理地址的,也就是MMU失败,将产生一个缺页中断,缺页中断的中断响应函数会在swap中寻找相对应的页面,如果找不到(也就是该文件从来没有被读入内存的情况),则会通过mmap()建立的映射关系,从硬盘上将文件读取到物理内存中,这个过程与内存映射无关。

       如果在拷贝数据时,发现物理内存不够用,则会通过虚拟内存机制(swap)将暂时不用的物理页面交换到硬盘上,如图1中过程4所示。这个过程也与内存映射无关。

    5. 效率:从代码层面上看,从硬盘上将文件读入内存,都要经过文件系统进行数据拷贝,并且数据拷贝操作是由文件系统和硬件驱动实现的,理论上来说,拷贝数据的效率是一样的。但是通过内存映射的方法访问硬盘上的文件,效率要比read和write系统调用高,这是为什么呢?原因是read()是系统调用其中进行了数据拷贝,它首先将文件内容从硬盘拷贝到内核空间的一个缓冲区,然后再将这些数据拷贝到用户空间,在这个过程中,实际上完成了 两次数据拷贝 ;而mmap()也是系统调用,如前所述,mmap()中没有进行数据拷贝,真正的数据拷贝是在缺页中断处理时进行的,由于mmap()将文件直接映射到用户空间,所以中断处理函数根据这个映射关系,直接将文件从硬盘拷贝到用户空间,只进行了 一次数据拷贝 。因此,内存映射的效率要比read/write效率高。

    6. 创建文件映射示例:
    7. #include <iostream>  
    8. #include <fcntl.h>  
    9. #include <io.h>  
    10. #include <afxwin.h>  
    11. using namespace std;  
    12.   
    13. int main()  
    14. {  
    15.     //开始  
    16. //1.获得文件句柄  创建一个文件内核对象
    17.     HANDLE hFile=CreateFile(              //失败返回INVALID_HANDLE_VALUE    
    18.         "c:\\test.dat",                   //文件名  
    19.         GENERIC_READ|GENERIC_WRITE,       //对文件进行读写操作,文件权限,
    20.         FILE_SHARE_READ|FILE_SHARE_WRITE, //共享模式
    21.         NULL,                             //安全属性
    22.         OPEN_EXISTING,                    //打开已存在文件  
    23.         FILE_ATTRIBUTE_NORMAL,            //文件或设备属性或标志
    24.         NULL);                               //模板模式
    25.   
    26.     //返回值size_high,size_low分别表示文件大小的高32位/低32位  
    27.     DWORD size_low,size_high;  
    28.     size_low= GetFileSize(hFile,&size_high);   
    29. //2.创建文件的内存映射文件, 创建一个文件映射内核对象
    30.     HANDLE hMapFile=CreateFileMapping   
    31.         hFile,           //文件名  
    32.         NULL,            //安全属性
    33.         PAGE_READWRITE,  //对映射文件进行读写  
    34.         size_high,      
    35.         size_low,        //这两个参数共64位,所以支持的最大文件长度为16EB  ,一共要映射多少到内存中
    36.         L"MyFileMap");   //映射的文件名字,其他进程,可通过此名字打开共享文件  
    37.     if(hMapFile==NULL)     //失败返回NULL
    38.     {     
    39.         AfxMessageBox("Can't create file mapping.Error%d:\n",   GetLastError());     
    40.         CloseHandle(hFile);  
    41.         return 0;     
    42.     }    
    43. //3.把文件数据映射到进程的地址空间  
    44.     void* pvFile=MapViewOfFile(       //失败返回NULL
    45.         hMapFile,                     //文件映射的句柄
    46.         FILE_MAP_READ|FILE_MAP_WRITE, //权限
    47.         0,                            //高位偏移
    48.         0,                            //低位偏移    
    49.         0);                           //一次映射多少 64K,如果是0,则映射从偏移量到文件末尾。
    50.     unsigned char *p=(unsigned char*)pvFile;   
    51.   
    52.     //至此,就获得了外部文件test.dat在内存地址空间的映射,  
    53. //4.用指针p"折磨"这个文件了  
    54.     CString s;  
    55.     p[size_low-1]='!';   
    56.     p[size_low-2]='X'//修改该文件的最后两个字节(文件大小<4GB高32位为0)  
    57.     s.Format("%s",p);  
    58.     //读文件的最后3个字节  
    59.     AfxMessageBox(s);  
    60. //5.结束  
    61.     //UnmapViewOfFile(pvFile); //撤销映射  
    62.     //CloseHandle(hFile); //关闭文件   
    63.     return 0;  
    64. }
    65. 打开文件映射示例:
    66. #include<iostream>
      #include<Windows.h>
      using namespace std;
      int main()
      {
      char szBuf[100];
      //1.打开文件映射对象
      //权限,继承性,名字
      HANDLE hFileMap = OpenFileMapping(FILE_MAP_ALL_ACCESS,NULL,L"MyFileMap");
      if(NULL == hFileMap) return 0;
      //2.将文件映射到进程地址空间
      char * pStartAddress = (char*)MapViewOfFile(hFileMap,FILE_MAP_ALL_ACCESS,0,0,0);
      //3.取出文件内容
      memcpy(szBuf,pStartAddress,100);
      //4.取消映射
      UnmapViewOfFile(hFileMap);
      system("pause");
      return 0;
      }
    展开全文
  • 内存映射文件原理

    2020-05-11 17:55:44
    内存映射文件内存映射文件与虚拟内存的区别映射原理mmap() 函数mmap基础概念mmap映射原理mmap优点mmap相关函数 内存映射文件与虚拟内存的区别   内存映射文件是由操作系统支持的一种文件处理方式,通过文件映射,...

    内存映射文件与虚拟内存的区别

      内存映射文件是由操作系统支持的一种文件处理方式,通过文件映射,让用户处理磁盘文件时就如同操作内存一样。再处理大文件时,效率比传统IO高很多。
      虚拟内存和内存映射文件都是将一部分文件加载到内存,另一部分文件保存在磁盘上的一种机制。但是二者是有区别的:

    1. 架构不同,虚拟内存是构建在物理内存之上的,引入原因是实际物理内存无法满足程序所需的内存空间;内存映射文件架构在进程地址空间之上,引入原因是无法将整个大文件全部加载到内存空间
    2. 虚拟内存管理的是页面文件,内存映射文件可以是任意磁盘文件。

    映射原理

      映射其实就是在虚拟地址空间和磁盘地址空间建立了一个一一对应关系,在逻辑地址空间为文件复配一个大小相等的逻辑空间。在文件映射过程中并没有数据拷贝,文件并没有放入内存,只是逻辑上放入了内存中,具体到代码就是建立了初始化数据结构,这个过程由mmap()系统调用实现的,所以映射效率非常高。
      映射过程如下:

    1. 调用mmap()函数,相当于给磁盘文件分配虚拟内存空间,它返回一个指针ptr,这个指针指向的是一个逻辑地址,操作系统要操作其中的数据必须通过MMU翻译才能获取对应的内存物理地址。
    2. 建立内存映射并没有数据拷贝,这时通过MMU翻译ptr是无法找到与之对应的内存物理地址的,也就是MMU失败,产生一个缺页中断,缺页中断响应函数会在磁盘的交换区查找相应页面,如果找不到证明文件还未读入磁盘,则通过mmp()建立的映射关系将文件加载到物理内存中,如果在交换区找到对应文件则换入
    3. 如果在数据拷贝过程中发现内存不够用,则通过虚拟内存管理将部分页面数据换出到交换区。

    mmap() 函数

    mmap基础概念

      mmap是一种内存映射文件的方法,是将文件或者其他对象映射到进程的地址空间中去,实现磁盘地址和虚拟空间地址一一对映关系,实现这样的映射关系后,进程就可以采用指针的方式操作这段内存,而系统会将修改后的脏页面自动写回磁盘中去。使用内存映射文件时,不用调用read,write等系统调用函数。内核空间对映射区域内容进行修改也能反映到用户空间,从而实现文件共享。
    在这里插入图片描述
      进程的虚拟地址空间由多个虚拟内存区域组成,虚拟内存区域是进程虚拟地址空间的一个同质区域,及具有同样特性的连续地址范围,上图中的text数据段、初始化数据段、bss数据段等都是一个独立的虚拟地址区域,内存映射文件地址空间处于堆、栈地址空间之间的空余部分。inux内核使用vm_area<struct结构来表示一个独立的虚拟内存区域,每个不同质的虚拟内存区域功能和内部机制都不一样,因此一个进程有多个vm_area_struct数据结构组成,每个数据结构使用链表相连,如下图(以上两图来自于此博文

    在这里插入图片描述
      vm_area_struct结构包含了区域起始地址和其他信息,mmap()函数就是创建了一个vm_area_struct结构,并将其与磁盘地址相连。

    mmap映射原理

      mmap映射分为三个阶段:

    (一)启动映射过程,创建一个虚拟映射区域,封装成vm_area_struct结构

    1. 进程调用用户空间库函数void *mmap(void *start, size_t length, int prot, int flags, int fd, off_t offset),在当前进程的虚拟空间找以一段连续的大小满足被映射文件大小要求的虚拟地址区域

    2. 为此虚拟地址区域分配一个vm_area_struct结构,并初始化该结构

    3. 将该结构插入进程的虚拟地址区域链中
      (二)调用内核空间的系统调用函数mmap(不同于用户空间的mmap库函数),实现物理地址与虚拟地址一一映射关系

    4. 通过内核函数int mmap(struct file *filp, struct vm_area_struct *vma)建立虚拟地址与磁盘地址的一一映射关系

    (三)进程发起对映射空间的访问,产生缺页中断,中断函数实现从磁盘拷贝到物理内存上

    1. 进程操作文件发现数据页没在内存中则到交换区中查找,如果找不到证明数据还未加载,因此内核直接将磁盘数据复制到用户空间中,实现高效拷贝

    mmap优点

    1. 对文件的读取操作跨过了页缓存,减少了数据的拷贝次数,用内存读写取代I/O读写,提高了文件读取效率
    2. 实现了用户空间和内核空间的高效交互方式。两空间的各自修改操作可以直接反映在映射的区域内,从而被对方空间及时捕捉
    3. 提供进程间共享内存及相互通信的方式。不管是父子进程还是无亲缘关系的进程,都可以将自身用户空间映射到同一个文件或匿名映射到同一片区域。从而通过各自对映射区域的改动,达到进程间通信和进程间共享的目的
    4. 可用于实现高效的大规模数据传输。内存空间不足,是制约大数据操作的一个方面,解决方案往往是借助硬盘空间协助操作,补充内存的不足。但是进一步会造成大量的文件I/O操作,极大影响效率。这个问题可以通过mmap映射很好的解决。换句话说,但凡是需要用磁盘空间代替内存的时候,mmap都可以发挥其功效

    mmap相关函数

    1. void *mmap(void *start, size_t length, int prot, int flags, int fd, off_t offset);
      成功执行时,mmap()返回被映射区的指针。失败时,mmap()返回MAP_FAILED[其值为(void *)-1]
      参数介绍:
      start:映射区的开始地址
      length:映射区的长度
      prot: 期望的内存保护标志
      fd:有效的文件描述词
      offset:被映射对象内容的起点

    2. int munmap( void * addr, size_t len )
      成功执行时,munmap()返回0。失败时,munmap返回-1。该调用在进程地址空间中解除一个映射关系,addr是调用mmap()时返回的地址,len是映射区的大小;

    参考:
    参考1
    参考2

    展开全文
  • 内存映射文件原理探索

    万次阅读 多人点赞 2016-11-27 17:10:09
    2.内存映射文件原理. 3.内存映射文件的效率. 4.传统IO和内存映射效率对比.虚拟内存内存映射文件的区别与联系 二者的联系虚拟内存内存映射文件都是将一部分内容加载到,另一部分放在磁盘上的一种机制,二者都...

    首先说说这篇文章要解决什么问题?
    1.虚拟内存与内存映射文件的区别与联系.
    2.内存映射文件的原理.
    3.内存映射文件的效率.
    4.传统IO和内存映射效率对比.

    虚拟内存与内存映射文件的区别与联系

     二者的联系

    虚拟内存和内存映射文件都是将一部分内容加载到,另一部分放在磁盘上的一种机制,二者都是应用程序动态性的基础,由于二者的虚拟性,对于用户都是透明的.
    虚拟内存其实就是硬盘的一部分,是计算机RAM与硬盘的数据交换区,因为实际的物理内存可能远小于进程的地址空间,这就需要把内存中暂时不用到的数据放到硬盘上一个特殊的地方,当请求的数据不在内存中时,系统产生却页中断,内存管理器便将对应的内存页重新从硬盘调入物理内存。
    内存映射文件是由一个文件到一块内存的映射,使应用程序可以通过内存指针对磁盘上的文件进行访问,其过程就如同对加载了文件的内存的访问,因此内存文件映射非常适合于用来管理大文件。

    二者的区别

    1.虚拟内存使用硬盘只能是页面文件,而内存映射使用的磁盘部分可以是任何磁盘文件.
    2.二者的架构不同,或者是说应用的场景不同,虚拟内存是架构在物理内存之上,其引入是因为实际的物理内存运行程序所需的空间,即使现在计算机中的物理内存越来越大,程序的尺寸也在增长。将所有运行着的程序全部加载到内存中不经济也非常不现实。内存映射文件架构在程序的地址空间之上,32位机地址空间只有4G,而某些大文件的尺寸可要要远超出这个值,因此,用地址空间中的某段应用文件中的一部分可解决处理大文件的问题,在32中,使用内存映射文件可以处理2的64次(64EB)大小的文件.原因内存映射文件,除了处理大文件,还可用作进程间通信。

    内存映射文件的原理

    “映射”就是建立一种对应关系,在这里主要是指硬盘上文件的位置与进程逻辑地址空间中一块相同区域之间一一对应,这种关系纯属是逻辑上的概念,物理上是不存在的,原因是进程的逻辑地址空间本身就是不存在的,在内存映射过程中,并没有实际的数据拷贝,文件没有被载入内存,只是逻辑上放入了内存,具体到代码,就是建立并初始化了相关的数据结构,这个过程有系统调用mmap()实现,所以映射的效率很高.

    这里写图片描述
                         内存映射原理
    上面说到建立内存映射没有进行实际的数据拷贝,那么进行进程又怎么能最终通过内存操作访问到硬盘上的文件呢?
    看上图:
    1.调用mmap(),相当于要给进行内存映射的文件分配了虚拟内存,它会返回一个指针ptr,这个ptr所指向的是一个逻辑地址,要操作其中的数据,必须通过MMU将逻辑地址转换成物理地址,如图1中过程2所示。
    2.建立内存映射并没有实际拷贝数据,这时,MMU在地址映射表中是无法找到与ptr相对应的物理地址的,也就是MMU失败,将产生一个缺页中断,缺 页中断的中断响应函数会在swap中寻找相对应的页面,如果找不到(也就是该文件从来没有被读入内存的情况),则会通过mmap()建立的映射关系,从硬 盘上将文件读取到物理内存中,如图1中过程3所示。
    3.如果在拷贝数据时,发现物理内存不够用,则会通过虚拟内存机制(swap)将暂时不用的物理页面交换到硬盘上,如图1中过程4所示。

    内存映射文件的效率

    了解过内存映射文件都知道,它比传统的IO读写数据快很多,那么,它为什么会这么快,从代码层面上来看,从硬盘上将文件读入内存,都是要经过数据拷贝,并且数据拷贝操作是由文件系统和硬件驱动实现的,理论上来说,拷贝数据的效率是一 样的。其实,原因是read()是系统调用,其中进行了数据 拷贝,它首先将文件内容从硬盘拷贝到内核空间的一个缓冲区,如图2中过程1,然后再将这些数据拷贝到用户空间,如图2中过程2,在这个过程中,实际上完成 了两次数据拷贝 ;而mmap()也是系统调用,如前所述,mmap()中没有进行数据拷贝,真正的数据拷贝是在缺页中断处理时进行的,由于mmap()将文件直接映射到用户空间,所以中断处理函数根据这个映射关系,直接将文件从硬盘拷贝到用户空间,只进行了 一次数据拷贝 。因此,内存映射的效率要比read/write效率高。
    这里写图片描述

                                        read系统调用原理
    

     传统IO和内存映射效率对比.

    在这里,使用java传统的IO,加缓冲区的IO,内存映射分别读取10M数据.用时如下:

    public class MapBufDelete {
        public static void main(String[] args) {
            try {
                FileInputStream fis=new FileInputStream("./largeFile.txt");
                int sum=0;
                int n;
                long t1=System.currentTimeMillis();
                try {
                    while((n=fis.read())>=0){
                        //  数据处理
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
                long t=System.currentTimeMillis()-t1;
                System.out.println("传统IOread文件,不使用缓冲区,用时:"+t);
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
    
            try {
                FileInputStream fis=new FileInputStream("./largeFile.txt");
                BufferedInputStream bis=new BufferedInputStream(fis);
                int sum=0;
                int n;
                long t1=System.currentTimeMillis();
                try {
                    while((n=bis.read())>=0){
                      //  数据处理
                    }
                } catch (IOException e) {
    
                    e.printStackTrace();
                }
                long t=System.currentTimeMillis()-t1;
                System.out.println("传统IOread文件,使用缓冲区,用时:"+t);
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
    
            MappedByteBuffer buffer=null;
            try {
                buffer=new RandomAccessFile("./largeFile.txt","rw").getChannel().map(FileChannel.MapMode.READ_WRITE, 0, 1253244);
                int sum=0;
                int n;
                long t1=System.currentTimeMillis();
                for(int i=0;i<1024*1024*10;i++){
                    //  数据处理
                }
                long t=System.currentTimeMillis()-t1;
                System.out.println("内存映射文件读取文件,用时:"+t);
            } catch (FileNotFoundException e) {
    
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
            }
    
        }
    }
    

    运行结果

    传统IOread文件,不使用缓冲区,用时:4739
    传统IOread文件,使用缓冲区,用时:59
    内存映射文件读取文件,用时:11
    

    最后,解释一下,为什么使用缓冲区读取文件会比不使用快:
    原因是每次进行IO操作,都要从用户态陷入内核态,由内核把数据从磁盘中读到内核缓冲区,再由内核缓冲区到用户缓冲区,如果没有buffer,读取都需要从用户态到内核态切换,而这种切换很耗时,所以,采用预读,减少IO次数,如果有buffer,根据局部性原理,就会一次多读数据,放到缓冲区中,减少了IO次数.

    展开全文
  • 内存映射文件与虚拟内存有些类似,通过内存映射文件可以保留一个地址空间的区域,同时将物理存储器提交给此区域,内存文件映射的物理存储器来自一个已经存在于磁盘上的文件,而且在对该文件进行操作之前必须首先对...

    Linux内存映射文件

          内存映射文件,是由一个文件到一块内存的映射。Win32提供了允许应用程序把文件映射到一个进程的函数 (CreateFileMapping)。内存映射文件与虚拟内存有些类似,通过内存映射文件可以保留一个地址空间的区域,同时将物理存储器提交给此区域,内存文件映射的物理存储器来自一个已经存在于磁盘上的文件,而且在对该文件进行操作之前必须首先对文件进行映射。使用内存映射文件处理存储于磁盘上的文件时,将不必再对文件执行I/O操作,使得内存映射文件在处理大数据量的文件时能起到相当重要的作用。

    有两种类型的内存映射文件:

    1.共享型,在线性区页上的任何写操作都会修改磁盘上的文件;而且如果进程对共享映射中的一个页进行写,那么这种修改对于其他映射了这同一文件的所有进程来说都是可见的。所以内存映射文件也可以作为进程通信的一种方式。

    2.私有型,当进程创建的映射只是为读文件,而不是写文件时才会使用这种映射。出于这种目的,私有映射的效率要比共享映射的效率更高。但是对私有映射页的任何写操作都会使内核停止映射该文件中的页。因此写操作既不会改变磁盘上的文件,对访问相同文件的其他进程也是不可见的。但是私有内存映射中的页会因为其他进程对文件的修改而更新。 

    内存映射文件通过mmap和munmap系统调用来实现. 

    mmap调用实际上就是一个内存对象vma的创建过程, mmap的调用格式是:

    void * mmap(void *start, size_t length, int prot , int flags, int fd, off_t offset);

    它的任何修改对其它进程都不可见. 而MAP_SHARED则无论修改与否都使用同一副本, 任何进程对页面的修改对其它进程都是可见的.

    mmap系统调用的实现过程是:

    1.先通过文件系统定位要映射的文件;

    2.权限检查, 映射的权限不会超过文件打开的方式, 也就是说如果文件是以只读方式打开, 那么则不允许建立一个可写映射;

    3.创建一个vma对象, 并对之进行初始化;

    4.调用映射文件的mmap函数, 其主要工作是给vm_ops向量表赋值;

    5.把该vma链入该进程的vma链表中, 如果可以和前后的vma合并则合并;

    6.如果是要求VM_LOCKED(映射区不被换出)方式映射, 则发出缺页请求, 把映射页面读入内存中.

     

    munmap(void * start, size_t length)

    该调用可以看作是 mmap的一个逆过程. 它将进程中从start开始length长度的一段区域的映射关闭, 如果该区域不是恰好对应一个vma, 则有可能会分割几个或几个vma.

    msync(void * start, size_t length, int flags):

    把映射区域的修改回写到后备存储中. 因为munmap时并不保证页面回写, 如果不调用msync, 那么有可能在munmap后丢失对映射区的修改. 其中flags可以是MS_SYNC, MS_ASYNC, MS_INVALIDATE, MS_SYNC要求回写完成后才返回, MS_ASYNC发出回写请求后立即返回, MS_INVALIDATE使用回写的内容更新该文件的其它映射. 该系统调用是通过调用映射文件的sync函数来完成工作的.

     

    brk(void * end_data_segement)

    将进程的数据段扩展到end_data_segement指定的地址, 该系统调用和mmap的实现方式十分相似, 同样是产生一个vma, 然后指定其属性. 不过在此之前需要做一些合法性检查, 比如该地址是否大于mm->end_code, end_data_segement和mm->brk之间是否还存在其它vma等等. 通过brk产生的vma映射的文件为空, 这和匿名映射产生的vma相似, 关于匿名映射不做进一步介绍. 库函数malloc就是通过brk实现的.

    展开全文
  • 原理  “映射”,就和数学课上说的“一一映射”是一个意思,就是建立一种一一对应关系,在这里...在内存映射的过程中,并没有实际的数据拷贝,文件没有被载入内存,只是逻辑上被放入了内存,具体到代码,就是建立并初
  • 内存映射原理

    2016-07-26 07:30:43
    4.3 内存映射原理 由于所有用户进程总的虚拟地址空间按可比可用的物理内存打得多,因此只有最常用的部分才与物理页帧关联。 text段你的情形类似,始终需要的只是其中一部分。 内核必须提供数据结构,一建立...
  • 内存文件映射

    千次阅读 2012-06-15 07:37:24
    一直都对内存映射文件这个概念很模糊,不知道它和虚拟内存有什么区别,而且映射这个词也很让人迷茫,今天终于搞清楚了。。。下面,我先解释一下我对映射这个词的理解,再区分一下几个容易混淆的概念,之后,什么是...
  • 虚拟内存机制 转载处:http://blog.csdn.net/zp373860147/article/details/7815793; 这是我找到的关于虚拟内存和分页机制的我个人比较容易理解的一篇文章。  虚拟存储器的思想是程序、数据和堆栈的大小都...
  • 1. 前言 最近研究Java中内存映射I/O。...本文章将从操作系统I/O调用原理讲解为什么内存映射文件MappedByteBuffer相比较Java I/O性能极高。话不多说,我们开始学习吧。 2. 浅谈Java I/O InputStr...
  • mongodb内存映射原理

    千次阅读 2019-07-05 15:15:01
    mongodb非常吃内存,为啥这么吃内存呢,mongodb使用的是内存映射存储引擎,即Memory Mapped Storage Engine,简称MMAP,MMAP可以把磁盘文件的一部分或全部内容直接映射内存,这样文件中的信息位置就会在内存中有...
  • 共享内存原理文件映射

    千次阅读 2018-08-26 18:53:23
    共享内存原理文件映射 mmap()是将指定的文件利用虚拟内存技术映射到内存中去,在内存中建立页表项,但mmap()调用建立的页表项后面地址为空,只有使用到某个地址空间时才给此页面分配空间,要涉及到页面置换,...
  • Memory mapped region for shared libraries 这一块就是直接虚拟内存映射文件,减少了文件拷贝到内核空间,再拷贝到用户空间 此图为 Linux 2.X 中的进程虚拟存储器,即进程的虚拟地址空间,如果你的机子是 32 位...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 140,968
精华内容 56,387
关键字:

内存文件映射的原理