mmap

最新推荐文章于 2023-07-25 10:41:40 发布
最新推荐文章于 2023-07-25 10:41:40 发布
阅读量1.8k 收藏 1
点赞数
文章标签： random struct 存储 file mongodb linux

http://kenby.iteye.com/blog/1164700



共享内存可以说是最有用的进程间通信方式，也是最快的IPC形式, 因为进程可以直接读写内存，而不需要任何

数据的拷贝。对于像管道和消息队列等通信方式，则需要在内核和用户空间进行四次的数据拷贝，而共享内存则

只拷贝两次数据: 一次从输入文件到共享内存区，另一次从共享内存区到输出文件。实际上，进程之间在共享内

存时，并不总是读写少量数据后就解除映射，有新的通信时，再重新建立共享内存区域。而是保持共享区域，直

到通信完毕为止，这样，数据内容一直保存在共享内存中，并没有写回文件。共享内存中的内容往往是在解除映

射时才写回文件的。因此，采用共享内存的通信方式效率是非常高的。

 

一. 传统文件访问

UNIX访问文件的传统方法是用open打开它们, 如果有多个进程访问同一个文件, 则每一个进程在自己的地址空间都包含有该

文件的副本,这不必要地浪费了存储空间. 下图说明了两个进程同时读一个文件的同一页的情形. 系统要将该页从磁盘读到高

速缓冲区中, 每个进程再执行一个存储器内的复制操作将数据从高速缓冲区读到自己的地址空间.

 

二. 共享存储映射

现在考虑另一种处理方法:　进程A和进程B都将该页映射到自己的地址空间, 当进程A第一次访问该页中的数据时, 它生成一

个缺页中断. 内核此时读入这一页到内存并更新页表使之指向它.以后, 当进程B访问同一页面而出现缺页中断时, 该页已经在

内存, 内核只需要将进程B的页表登记项指向次页即可. 如下图所示: 

 

三、mmap()及其相关系统调用

mmap()系统调用使得进程之间通过映射同一个普通文件实现共享内存。普通文件被映射到进程地址空间后，进程可以向访

问普通内存一样对文件进行访问，不必再调用read()，write（）等操作。

 

mmap()系统调用形式如下：

void* mmap ( void * addr , size_t len , int prot , int flags , int fd , off_t offset ) 

mmap的作用是映射文件描述符fd指定文件的 [off,off + len]区域至调用进程的[addr, addr + len]的内存区域, 如下图所示:

 

参数fd为即将映射到进程空间的文件描述字，一般由open()返回，同时，fd可以指定为-1，此时须指定flags参数中的

MAP_ANON，表明进行的是匿名映射（不涉及具体的文件名，避免了文件的创建及打开，很显然只能用于具有亲缘关系的

进程间通信）。

len是映射到调用进程地址空间的字节数，它从被映射文件开头offset个字节开始算起。

prot 参数指定共享内存的访问权限。可取如下几个值的或：PROT_READ（可读） , PROT_WRITE （可写）, PROT_EXEC （可执行）, PROT_NONE（不可访问）。

flags由以下几个常值指定：MAP_SHARED , MAP_PRIVATE , MAP_FIXED，其中，MAP_SHARED , MAP_PRIVATE必

选其一，而MAP_FIXED则不推荐使用。

offset参数一般设为0，表示从文件头开始映射。

参数addr指定文件应被映射到进程空间的起始地址，一般被指定一个空指针，此时选择起始地址的任务留给内核来完成。函

数的返回值为最后文件映射到进程空间的地址，进程可直接操作起始地址为该值的有效地址。
四. mmap的两个例子
范例中使用的测试文件 data.txt: 
Xml代码  收藏代码
  1. aaaaaaaaa  
  2. bbbbbbbbb  
  3. ccccccccc  
  4. ddddddddd  
 
1 通过共享映射的方式修改文件

C代码  收藏代码
  1. #include <sys/mman.h>  
  2. #include <sys/stat.h>  
  3. #include <fcntl.h>  
  4. #include <stdio.h>  
  5. #include <stdlib.h>  
  6. #include <unistd.h>  
  7. #include <error.h>  
  8.   
  9. #define BUF_SIZE 100  
  10.   
  11. int main(int argc, char **argv)  
  12. {  
  13.     int fd, nread, i;  
  14.     struct stat sb;  
  15.     char *mapped, buf[BUF_SIZE];  
  16.   
  17.     for (i = 0; i < BUF_SIZE; i++) {  
  18.         buf[i] = '#';  
  19.     }  
  20.   
  21.     /* 打开文件 */  
  22.     if ((fd = open(argv[1], O_RDWR)) < 0) {  
  23.         perror("open");  
  24.     }  
  25.   
  26.     /* 获取文件的属性 */  
  27.     if ((fstat(fd, &sb)) == -1) {  
  28.         perror("fstat");  
  29.     }  
  30.   
  31.     /* 将文件映射至进程的地址空间 */  
  32.     if ((mapped = (char *)mmap(NULL, sb.st_size, PROT_READ |   
  33.                     PROT_WRITE, MAP_SHARED, fd, 0)) == (void *)-1) {  
  34.         perror("mmap");  
  35.     }  
  36.   
  37.     /* 映射完后, 关闭文件也可以操纵内存 */  
  38.     close(fd);  
  39.   
  40.     printf("%s", mapped);  
  41.   
  42.     /* 修改一个字符,同步到磁盘文件 */  
  43.     mapped[20] = '9';  
  44.     if ((msync((void *)mapped, sb.st_size, MS_SYNC)) == -1) {  
  45.         perror("msync");  
  46.     }  
  47.   
  48.     /* 释放存储映射区 */  
  49.     if ((munmap((void *)mapped, sb.st_size)) == -1) {  
  50.         perror("munmap");  
  51.     }  
  52.   
  53.     return 0;  
  54. }  
 
2 私有映射无法修改文件

/* 将文件映射至进程的地址空间 */
if ((mapped = (char *)mmap(NULL, sb.st_size, PROT_READ | 
                    PROT_WRITE, MAP_PRIVATE, fd, 0)) == (void *)-1) {
    perror("mmap");
}
 

五. 使用共享映射实现两个进程之间的通信
两个程序映射同一个文件到自己的地址空间, 进程A先运行, 每隔两秒读取映射区域, 看是否发生变化. 
进程B后运行, 它修改映射区域, 然后推出, 此时进程A能够观察到存储映射区的变化
进程A的代码:
C代码  收藏代码
  1. #include <sys/mman.h>  
  2. #include <sys/stat.h>  
  3. #include <fcntl.h>  
  4. #include <stdio.h>  
  5. #include <stdlib.h>  
  6. #include <unistd.h>  
  7. #include <error.h>  
  8.   
  9. #define BUF_SIZE 100  
  10.   
  11. int main(int argc, char **argv)  
  12. {  
  13.     int fd, nread, i;  
  14.     struct stat sb;  
  15.     char *mapped, buf[BUF_SIZE];  
  16.   
  17.     for (i = 0; i < BUF_SIZE; i++) {  
  18.         buf[i] = '#';  
  19.     }  
  20.   
  21.     /* 打开文件 */  
  22.     if ((fd = open(argv[1], O_RDWR)) < 0) {  
  23.         perror("open");  
  24.     }  
  25.   
  26.     /* 获取文件的属性 */  
  27.     if ((fstat(fd, &sb)) == -1) {  
  28.         perror("fstat");  
  29.     }  
  30.   
  31.     /* 将文件映射至进程的地址空间 */  
  32.     if ((mapped = (char *)mmap(NULL, sb.st_size, PROT_READ |   
  33.                     PROT_WRITE, MAP_SHARED, fd, 0)) == (void *)-1) {  
  34.         perror("mmap");  
  35.     }  
  36.   
  37.     /* 文件已在内存, 关闭文件也可以操纵内存 */  
  38.     close(fd);  
  39.       
  40.     /* 每隔两秒查看存储映射区是否被修改 */  
  41.     while (1) {  
  42.         printf("%s\n", mapped);  
  43.         sleep(2);  
  44.     }  
  45.   
  46.     return 0;  
  47. }  
 
进程B的代码:
C代码  收藏代码
  1. #include <sys/mman.h>  
  2. #include <sys/stat.h>  
  3. #include <fcntl.h>  
  4. #include <stdio.h>  
  5. #include <stdlib.h>  
  6. #include <unistd.h>  
  7. #include <error.h>  
  8.   
  9. #define BUF_SIZE 100  
  10.   
  11. int main(int argc, char **argv)  
  12. {  
  13.     int fd, nread, i;  
  14.     struct stat sb;  
  15.     char *mapped, buf[BUF_SIZE];  
  16.   
  17.     for (i = 0; i < BUF_SIZE; i++) {  
  18.         buf[i] = '#';  
  19.     }  
  20.   
  21.     /* 打开文件 */  
  22.     if ((fd = open(argv[1], O_RDWR)) < 0) {  
  23.         perror("open");  
  24.     }  
  25.   
  26.     /* 获取文件的属性 */  
  27.     if ((fstat(fd, &sb)) == -1) {  
  28.         perror("fstat");  
  29.     }  
  30.   
  31.     /* 私有文件映射将无法修改文件 */  
  32.     if ((mapped = (char *)mmap(NULL, sb.st_size, PROT_READ |   
  33.                     PROT_WRITE, MAP_PRIVATE, fd, 0)) == (void *)-1) {  
  34.         perror("mmap");  
  35.     }  
  36.   
  37.     /* 映射完后, 关闭文件也可以操纵内存 */  
  38.     close(fd);  
  39.   
  40.     /* 修改一个字符 */  
  41.     mapped[20] = '9';  
  42.    
  43.     return 0;  
  44. }  
 
六. 通过匿名映射实现父子进程通信
C代码  收藏代码
  1. #include <sys/mman.h>  
  2. #include <stdio.h>  
  3. #include <stdlib.h>  
  4. #include <unistd.h>  
  5.   
  6. #define BUF_SIZE 100  
  7.   
  8. int main(int argc, char** argv)  
  9. {  
  10.     char    *p_map;  
  11.   
  12.     /* 匿名映射,创建一块内存供父子进程通信 */  
  13.     p_map = (char *)mmap(NULL, BUF_SIZE, PROT_READ | PROT_WRITE,  
  14.             MAP_SHARED | MAP_ANONYMOUS, -1, 0);  
  15.   
  16.     if(fork() == 0) {  
  17.         sleep(1);  
  18.         printf("child got a message: %s\n", p_map);  
  19.         sprintf(p_map, "%s", "hi, dad, this is son");  
  20.         munmap(p_map, BUF_SIZE); //实际上，进程终止时，会自动解除映射。  
  21.         exit(0);  
  22.     }  
  23.   
  24.     sprintf(p_map, "%s", "hi, this is father");  
  25.     sleep(2);  
  26.     printf("parent got a message: %s\n", p_map);  
  27.   
  28.     return 0;  
  29. }  
 

 

七. 对mmap()返回地址的访问
linux采用的是页式管理机制。对于用mmap()映射普通文件来说，进程会在自己的地址空间新增一块空间，空间大
小由mmap()的len参数指定，注意，进程并不一定能够对全部新增空间都能进行有效访问。进程能够访问的有效地址大小取决于文件被映射部分的大小。简单的说，能够容纳文件被映射部分大小的最少页面个数决定了进程从mmap()返回的地址开始，能够有效访问的地址空间大小。超过这个空间大小，内核会根据超过的严重程度返回发送不同的信号给进程。可用如下图示说明：

 

总结一下就是, 文件大小, mmap的参数 len 都不能决定进程能访问的大小, 而是容纳文件被映射部分的最小页面数决定

进程能访问的大小. 下面看一个实例:

 

 

C代码  收藏代码
  1. #include <sys/mman.h>  
  2. #include <sys/types.h>  
  3. #include <sys/stat.h>  
  4. #include <fcntl.h>  
  5. #include <unistd.h>  
  6. #include <stdio.h>  
  7.   
  8. int main(int argc, char** argv)  
  9. {  
  10.     int fd,i;  
  11.     int pagesize,offset;  
  12.     char *p_map;  
  13.     struct stat sb;  
  14.   
  15.     /* 取得page size */  
  16.     pagesize = sysconf(_SC_PAGESIZE);  
  17.     printf("pagesize is %d\n",pagesize);  
  18.   
  19.     /* 打开文件 */  
  20.     fd = open(argv[1], O_RDWR, 00777);  
  21.     fstat(fd, &sb);  
  22.     printf("file size is %zd\n", (size_t)sb.st_size);  
  23.   
  24.     offset = 0;   
  25.     p_map = (char *)mmap(NULL, pagesize * 2, PROT_READ|PROT_WRITE,   
  26.             MAP_SHARED, fd, offset);  
  27.     close(fd);  
  28.       
  29.     p_map[sb.st_size] = '9';  /* 导致总线错误 */  
  30.     p_map[pagesize] = '9';    /* 导致段错误 */  
  31.   
  32.     munmap(p_map, pagesize * 2);  
  33.   
  34.     return 0;  
  35. }  




http://wenku.baidu.com/view/e7d9b222bcd126fff7050b53.html



http://learn.akae.cn/media/ch28s09.html


http://blog.nosqlfan.com/html/2956.html



Linux虚拟内存实现原理

作者：nosqlfan on 星期四, 九月 1, 2011 · 4条评论 【阅读：3,035 次】 

下面是一篇翻译文章，原文出自MongoDB的核心开发工程师 Kristina Chodorow 的个人博客，由NoSQLFan翻译整理。

我们都知道，MongoDB 使用内存映射的方式来进行数据文件的存取操作。本文的目的就在于描述操作系统虚拟内存的使用及内存映射的内部实现。

以下是译文

当你运行一个程序，程序中有许多东西需要存储，堆、栈以及各种功能库。而这一切在你写程序时可能都不需要自己控制，Linux内核会帮你完成这些存储的调度，你只需要告诉它你需要做什么，内核就会在合适的地方给你分配内存空间。本文主要通过几个实例程序的内存使用研究，来为大家展示Linux的内存使用状况。

第一个例子：下面一段程序会打印出程序的pid（进程号）后挂起。

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>

int main() {
  printf("run `pmap %d`\n", getpid());
  pause();
}

将上面代码保存成文件 mem_munch.c 然后运行下面程序编译并执行：

$ gcc mem_munch.c -o mem_munch
$ ./mem_munch
run `pmap 25681`

上面进程号是25681，可能你试验的结果会不太一样。

下面我们通过pmap命令来查看一下这个小程序的内存使用情况

$ pmap 25681
25681:   ./mem_munch
0000000000400000      4K r-x--  /home/user/mem_munch
0000000000600000      4K r----  /home/user/mem_munch
0000000000601000      4K rw---  /home/user/mem_munch
00007fcf5af88000   1576K r-x--  /lib/x86_64-linux-gnu/libc-2.13.so
00007fcf5b112000   2044K -----  /lib/x86_64-linux-gnu/libc-2.13.so
00007fcf5b311000     16K r----  /lib/x86_64-linux-gnu/libc-2.13.so
00007fcf5b315000      4K rw---  /lib/x86_64-linux-gnu/libc-2.13.so
00007fcf5b316000     24K rw---    [ anon ]
00007fcf5b31c000    132K r-x--  /lib/x86_64-linux-gnu/ld-2.13.so
00007fcf5b512000     12K rw---    [ anon ]
00007fcf5b539000     12K rw---    [ anon ]
00007fcf5b53c000      4K r----  /lib/x86_64-linux-gnu/ld-2.13.so
00007fcf5b53d000      8K rw---  /lib/x86_64-linux-gnu/ld-2.13.so
00007fff7efd8000    132K rw---    [ stack ]
00007fff7efff000      4K r-x--    [ anon ]
ffffffffff600000      4K r-x--    [ anon ]
 total             3984K

上面的结果是这个程序的内存使用情况，其实更确切的说是这个程序认为它使用内存的情况。从上面的结果我们能看到，当你访问libc库时，实际上是对内存地址00007fcf5af88000的访问，当你访问ld库时，实际上是对内存地址00007fcf5b31c000的访问。

上面的输出可能还比较抽象，下面我们修改一下上面的程序，我们在程序的堆和栈上各放一块数据。

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <stdlib.h>

int main() {
  int on_stack, *on_heap;

  //局部变量是放在栈上的，所以 on_stack 的地址就是栈的初始地址
  on_stack = 42;
  printf("stack address: %p\n", &on_stack);

  //malloc 的内存是在堆上分配的
  on_heap = (int*)malloc(sizeof(int));
  printf("heap address: %p\n", on_heap);

  printf("run `pmap %d`\n", getpid());
  pause();
}

编译运行：

$ ./mem_munch
stack address: 0x7fff497670bc
heap address: 0x1b84010
run `pmap 11972`

然后再用pmap命令查看一下内存使用：

$ pmap 11972
11972:   ./mem_munch
0000000000400000      4K r-x--  /home/user/mem_munch
0000000000600000      4K r----  /home/user/mem_munch
0000000000601000      4K rw---  /home/user/mem_munch
0000000001b84000    132K rw---    [ anon ]
00007f3ec4d98000   1576K r-x--  /lib/x86_64-linux-gnu/libc-2.13.so
00007f3ec4f22000   2044K -----  /lib/x86_64-linux-gnu/libc-2.13.so
00007f3ec5121000     16K r----  /lib/x86_64-linux-gnu/libc-2.13.so
00007f3ec5125000      4K rw---  /lib/x86_64-linux-gnu/libc-2.13.so
00007f3ec5126000     24K rw---    [ anon ]
00007f3ec512c000    132K r-x--  /lib/x86_64-linux-gnu/ld-2.13.so
00007f3ec5322000     12K rw---    [ anon ]
00007f3ec5349000     12K rw---    [ anon ]
00007f3ec534c000      4K r----  /lib/x86_64-linux-gnu/ld-2.13.so
00007f3ec534d000      8K rw---  /lib/x86_64-linux-gnu/ld-2.13.so
00007fff49747000    132K rw---    [ stack ]
00007fff497bb000      4K r-x--    [ anon ]
ffffffffff600000      4K r-x--    [ anon ]
 total             4116K

这次多出了上面红色的一行内容，红色内容就是堆的起始位置：

0000000001b84000    132K rw---    [ anon ]

在我们程序运行的输出里也有一行红色的输出，这是这个地址在程序中的内存地址：

heap address: 0x1b84010

这两个地址基本上是一样的，其中的anon是Anonymous的缩写，表明这段内存是没有文件映射的。

我们再看上面绿色的两行，与上面相对应，这两行分别是用pmap 和应用程序看到的栈起始地址：

00007fff49747000    132K rw---    [ stack ]
stack address: 0x7fff497670bc

上面说到的内存使用，都只是程序认为自己对内存的使用，实际上程序在分配内存是不知道系统内存的状态的。所以上面的输出都只是从程序自己的角度看到的内存使用状况。比如在上面的例子中，我们看到程序的内存地址空间是从0×0000000000400000到0xffffffffff600000的所有地址（而0xffffffffff600000到0×00007fffffffffffffff之间的地址是有特殊用处的，这里不多讲）。这样算下来，我们总共可以使用的内存空间有1千万TB。

但是实际上目前没有硬件能有1千万TB的物理内存。为什么操作系统会如此设计呢？原因有很多，可以看这里，但也正因此，我们可以使用远远超出物理内存大小的内存空间。

内存映射

内存映射的原理就是让操作系统将一个文件映射到一段内存中，然后在操作这个文件内存就可以像操作内存一样。比如我们创建一个完全内容随机的文件，然后将它用内存映射的方式映射到一段内存空间中。那么我们在这段内存中随便取一位就相当于取到了一个随机数。下面就让我们来做这个实验，先用下面命令生成一个内容随机的文件。

$ dd if=/dev/urandom bs=1024 count=1000000 of=/home/user/random
1000000+0 records in
1000000+0 records out
1024000000 bytes (1.0 GB) copied, 123.293 s, 8.3 MB/s
$ ls -lh random
-rw-r--r-- 1 user user 977M 2011-08-29 16:46 random

然后我们用下面程序来将这个文件内容映射到内存，再从中取出随机数

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <stdlib.h>
#include <sys/mman.h>

int main() {
  char *random_bytes;
  FILE *f;
  int offset = 0;

  // open "random" for reading
  f = fopen("/home/user/random", "r");
  if (!f) {
    perror("couldn't open file");
    return -1;
  }

  // we want to inspect memory before mapping the file
  printf("run `pmap %d`, then press ", getpid());
  getchar();

  random_bytes = mmap(0, 1000000000, PROT_READ, MAP_SHARED, fileno(f), 0);

  if (random_bytes == MAP_FAILED) {
    perror("error mapping the file");
    return -1;
  }

  while (1) {
    printf("random number: %d (press  for next number)", *(int*)(random_bytes+offset));
    getchar();

    offset += 4;
  }
}

然后运行这个程序：

 $ ./mem_munch
run `pmap 12727`, then press

下面我们通过一次次的按下回车键来从这个文件中读取随机数，按下几次后我们可以再通过pmap来查看其内存空间的情况：

$ pmap 12727
12727:   ./mem_munch
0000000000400000      4K r-x--  /home/user/mem_munch
0000000000600000      4K r----  /home/user/mem_munch
0000000000601000      4K rw---  /home/user/mem_munch
000000000147d000    132K rw---    [ anon ]
00007fe261c6f000 976564K r--s-  /home/user/random
00007fe29d61c000   1576K r-x--  /lib/x86_64-linux-gnu/libc-2.13.so
00007fe29d7a6000   2044K -----  /lib/x86_64-linux-gnu/libc-2.13.so
00007fe29d9a5000     16K r----  /lib/x86_64-linux-gnu/libc-2.13.so
00007fe29d9a9000      4K rw---  /lib/x86_64-linux-gnu/libc-2.13.so
00007fe29d9aa000     24K rw---    [ anon ]
00007fe29d9b0000    132K r-x--  /lib/x86_64-linux-gnu/ld-2.13.so
00007fe29dba6000     12K rw---    [ anon ]
00007fe29dbcc000     16K rw---    [ anon ]
00007fe29dbd0000      4K r----  /lib/x86_64-linux-gnu/ld-2.13.so
00007fe29dbd1000      8K rw---  /lib/x86_64-linux-gnu/ld-2.13.so
00007ffff29b2000    132K rw---    [ stack ]
00007ffff29de000      4K r-x--    [ anon ]
ffffffffff600000      4K r-x--    [ anon ]
 total           980684K

上面的输出和之前的大同小异，但是多出了上面红色的一行。这是我们上面的随机文件映射到内存中的内存。我们再使用pmap -x 选项来查看一下程序的内存使用，会得到下面的内容，其中RSS（resident set size）列表示真实占用的内存。

pmap -x 12727
12727:   ./mem_munch
Address           Kbytes     RSS   Dirty Mode   Mapping
0000000000400000       0       4       0 r-x--  mem_munch
0000000000600000       0       4       4 r----  mem_munch
0000000000601000       0       4       4 rw---  mem_munch
000000000147d000       0       4       4 rw---    [ anon ]
00007fe261c6f000       0       4       0 r--s-  random
00007fe29d61c000       0     288       0 r-x--  libc-2.13.so
00007fe29d7a6000       0       0       0 -----  libc-2.13.so
00007fe29d9a5000       0      16      16 r----  libc-2.13.so
00007fe29d9a9000       0       4       4 rw---  libc-2.13.so
00007fe29d9aa000       0      16      16 rw---    [ anon ]
00007fe29d9b0000       0     108       0 r-x--  ld-2.13.so
00007fe29dba6000       0      12      12 rw---    [ anon ]
00007fe29dbcc000       0      16      16 rw---    [ anon ]
00007fe29dbd0000       0       4       4 r----  ld-2.13.so
00007fe29dbd1000       0       8       8 rw---  ld-2.13.so
00007ffff29b2000       0      12      12 rw---    [ stack ]
00007ffff29de000       0       4       0 r-x--    [ anon ]
ffffffffff600000       0       0       0 r-x--    [ anon ]
----------------  ------  ------  ------
total kB          980684     508     100

如果你的虚拟内存占用（上面的Kbytes列）都是0，不用担心，这是一个在Debian/Ubuntu系统上pmap -x命令的bug。最后一行输出的总占用量是正确的。

现在你可以看一下RSS那一列，这就是实际内存占用。在random文件上，你的程序实际上可以访问在00007fe261c6f000之前的数十亿字节的内存地址，但是只要你访问的地址超过4KB，那么操作系统就会去磁盘上查找内容。也就是说实际上只有4KB的物理内存被使用了。只有访问这4KB的东西时，才是真正的内存操作。其它部分虽然你使用的也是内存操作函数来访问它，但是由于它没有被加载到内存中，所以在这些内容被访问的时候，操作系统会先去磁盘读random中读取内容到内存中。

如果我们把程序再修改一下，修改成下面这样，让程序把整个random文件都访问一遍。

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <stdlib.h>
#include <sys/mman.h>

int main() {
  char *random_bytes;
  FILE *f;
  int offset = 0;

  // open "random" for reading
  f = fopen("/home/user/random", "r");
  if (!f) {
    perror("couldn't open file");
    return -1;
  }

  random_bytes = mmap(0, 1000000000, PROT_READ, MAP_SHARED, fileno(f), 0);

  if (random_bytes == MAP_FAILED) {
    printf("error mapping the file\n");
    return -1;
  }

  for (offset = 0; offset < 1000000000; offset += 4) {
    int i = *(int*)(random_bytes+offset);

    // to show we're making progress
    if (offset % 1000000 == 0) {
      printf(".");
    }
  }

  // at the end, wait for signal so we can check mem
  printf("\ndone, run `pmap -x %d`\n", getpid());
  pause();
}

现在我们的pmap -x命令就会得到如下输出：

$ pmap -x 5378
5378:   ./mem_munch
Address           Kbytes     RSS   Dirty Mode   Mapping
0000000000400000       0       4       4 r-x--  mem_munch
0000000000600000       0       4       4 r----  mem_munch
0000000000601000       0       4       4 rw---  mem_munch
0000000002271000       0       4       4 rw---    [ anon ]
00007fc2aa333000       0  976564       0 r--s-  random
00007fc2e5ce0000       0     292       0 r-x--  libc-2.13.so
00007fc2e5e6a000       0       0       0 -----  libc-2.13.so
00007fc2e6069000       0      16      16 r----  libc-2.13.so
00007fc2e606d000       0       4       4 rw---  libc-2.13.so
00007fc2e606e000       0      16      16 rw---    [ anon ]
00007fc2e6074000       0     108       0 r-x--  ld-2.13.so
00007fc2e626a000       0      12      12 rw---    [ anon ]
00007fc2e6290000       0      16      16 rw---    [ anon ]
00007fc2e6294000       0       4       4 r----  ld-2.13.so
00007fc2e6295000       0       8       8 rw---  ld-2.13.so
00007fff037e6000       0      12      12 rw---    [ stack ]
00007fff039c9000       0       4       0 r-x--    [ anon ]
ffffffffff600000       0       0       0 r-x--    [ anon ]
----------------  ------  ------  ------
total kB          980684  977072     104

我们可以看到，random文件映射实际占用内存量已经和random文件大小一致了，也就是也random文件通过循环访问，其内容已经完全加载到内存中了。现在我们再访问random文件的任何部分，实际上都是内存操作。而不会穿透到磁盘。

话说回来，这就是为什么MongoDB的内存使用，可以远远超出操作系统物理内存大小。

来源：www.snailinaturtleneck.com



Linux的mmap文件内存映射机制

mmap: memory map

在讲述文件映射的概念时, 不可避免的要牵涉到虚存(SVR 4的VM). 实际上, 文件映射是虚存的中心概念, 文件映射一方面给用户提供了一组措施, 好似用户将文件映射到自己地址空间的某个部分, 使用简单的内存访问指令读写文件；另一方面, 它也可以用于内核的基本组织模式, 在这种模式种, 内核将整个地址空间视为诸如文件之类的一组不同对象的映射. 中的传统文件访问方式是, 首先用open系统调用打开文件, 然后使用read, write以及lseek等调用进行顺序或者随即的I/O. 这种方式是非常低效的, 每一次I/O操作都需要一次系统调用. 另外, 如果若干个进程访问同一个文件, 每个进程都要在自己的地址空间维护一个副本, 浪费了内存空间. 而如果能够通过一定的机制将页面映射到进程的地址空间中, 也就是说首先通过简单的产生某些内存管理数据结构完成映射的创建. 当进程访问页面时产生一个缺页中断, 内核将页面读入内存并且更新页表指向该页面. 而且这种方式非常方便于同一副本的共享.

VM是面向对象的方法设计的, 这里的对象是指内存对象: 内存对象是一个软件抽象的概念, 它描述内存区与后备存储之间的映射. 系统可以使用多种类型的后备存储, 比如交换空间, 本地或者远程文件以及帧缓存等等. VM系统对它们统一处理, 采用同一操作集操作, 比如读取页面或者回写页面等. 每种不同的后备存储都可以用不同的方法实现这些操作. 这样, 系统定义了一套统一的接口, 每种后备存储给出自己的实现方法. 这样, 进程的地址空间就被视为一组映射到不同数据对象上的的映射组成. 所有的有效地址就是那些映射到数据对象上的地址. 这些对象为映射它的页面提供了持久性的后备存储. 映射使得用户可以直接寻址这些对象.

值得提出的是, VM体系结构独立于Unix系统, 所有的Unix系统语义, 如正文, 数据及堆栈区都可以建构在基本VM系统之上. 同时, VM体系结构也是独立于存储管理的, 存储管理是由操作系统实施的, 如: 究竟采取什么样的对换和请求调页算法, 究竟是采取分段还是分页机制进行存储管理, 究竟是如何将虚拟地址转换成为物理地址等等(Linux中是一种叫Three Level Page Table的机制), 这些都与内存对象的概念无关.

下面介绍Linux中VM的实现. 

一个进程应该包括一个mm_struct(memory manage struct), 该结构是进程虚拟地址空间的抽象描述, 里面包括了进程虚拟空间的一些管理信息: start_code, end_code, start_data, end_data, start_brk, end_brk等等信息. 另外, 也有一个指向进程虚存区表(vm_area_struct: virtual memory area)的指针, 该链是按照虚拟地址的增长顺序排列的. 在Linux进程的地址空间被分作许多区(vma), 每个区(vma)都对应虚拟地址空间上一段连续的区域, vma是可以被共享和保护的独立实体, 这里的vma就是前面提到的内存对象. 下面是vm_area_struct的结构, 其中, 前半部分是公共的, 与类型无关的一些数据成员, 如: 指向mm_struct的指针, 地址范围等等, 后半部分则是与类型相关的成员, 其中最重要的是一个指向vm_operation_struct向量表的指针vm_ops, vm_pos向量表是一组虚函数, 定义了与vma类型无关的接口. 每一个特定的子类, 即每种vma类型都必须在向量表中实现这些操作. 这里包括了: open, close, unmap, protect, sync, nopage, wppage, swapout这些操作.

struct vm_area_struct {

/*公共的, 与vma类型无关的 */

struct mm_struct * vm_mm; 
unsigned long vm_start; 
unsigned long vm_end; 
struct vm_area_struct *vm_next; 
pgprot_t vm_page_prot; 
unsigned long vm_flags; 
short vm_avl_height; 
struct vm_area_struct * vm_avl_left; 
struct vm_area_struct * vm_avl_right; 
struct vm_area_struct *vm_next_share; 
struct vm_area_struct **vm_pprev_share;

/* 与类型相关的 */

struct vm_operations_struct * vm_ops; 
unsigned long vm_pgoff; 
struct file * vm_file; 
unsigned long vm_raend； 
void * vm_private_data;
}; 
vm_ops: open, close, no_page, swapin, swapout……


介绍完VM的基本概念后, 我们可以讲述mmap和munmap系统调用了. mmap调用实际上就是一个内存对象vma的创建过程, mmap的调用格式是:

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

其中start是映射地址, length是映射长度, 如果flags的MAP_FIXED不被置位, 则该参数通常被忽略, 而查找进程地址空间中第一个长度符合的空闲区域；Fd是映射文件的文件句柄, offset是映射文件中的偏移地址；prot是映射保护权限, 可以是PROT_EXEC, PROT_READ, PROT_WRITE, PROT_NONE, flags则是指映射类型, 可以是MAP_FIXED, MAP_PRIVATE, MAP_SHARED, 该参数必须被指定为MAP_PRIVATE和MAP_SHARED其中之一, MAP_PRIVATE是创建一个写时拷贝映射(copy-on-write), 也就是说如果有多个进程同时映射到一个文件上, 映射建立时只是共享同样的存储页面, 但是某进程企图修改页面内容, 则复制一个副本给该进程私用, 它的任何修改对其它进程都不可见. 而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实现的.
wukui1008
关注
mmap打开工具快速安装
04-04
标题中的“mmap打开工具快速安装”指的是使用特定软件（如MindManager）来处理和查看mmap文件。mmap，全称Memory-Mapped File，是一种内存映射文件的技术，允许程序将文件的内容直接映射到内存空间，以便高效地读写...
资源网址，共享
qq_20612759的博客
08-31 4万+
github https://github.com/yiminyangguang520/qt/commit/3ef46ce8b37c4f0fc244b05e161864c0819ea829
怎么用手机看fc2高清视频，详细图文方法
weixin_33955681的博客
04-25 10万+
有很多手机用户想用Fc2视频应用却因为地域问题无法使用。就算侥幸找到了免费域名打开，进去了！也会发生通信错误！这里小编教大家完美解决方法。！工具/原料·外游***的独享专线账号一个准备工作·首先你要先下载准备好应用解决方法1.我们需要先找到手机里的×××系统2.点击进去。新增一个×××。填入你的外游×××独享服务器！在按图上设定好之后点击确定储存3.之后会...
盘点日本人最常用的50个网站
热门推荐
朝花夕拾的博客
07-25 14万+
日本雅虎在日本简直就是神一样的存在，发生什么突发事情，日本人第一直觉就是上日本雅虎上看看新闻。アマゾン在日本的物流非常强，在日本的信誉也是居各大购物网站之首。不过，即使同样的商品在亚马逊上面价格也会贵一些，在上面消费的人都是收入较高些，追求安心的人（印象）。自从FB登陸了日本，本土的SNS服务Mixi就节节败退，现在几乎都是FB的天下了。有很多知名的明星艺人在上面开有自己的专栏博客，在日本，博客服务仍然是相当受欢迎的哦。所以嘛，百度在日本也是很厉害的哦，只是使用的基本上都是中国人而已。、地図、乗り換え等。
Fc2显示服务器拥挤,fc2视频全攻略
weixin_28839439的博客
08-06 4万+
作者：小鱼的互联网观察发布时间：January 29, 2014分类：linux首先给pi安装raspbian。然后：sudo passwd root 修改root用户密码然后exit重新使用root用户登录。接着运行下面的shellsudo apt-get install mysql-server mysql-clientsudo apt-get install php5sudo apt-g...
mmap2.rar_mmap
07-14
在linux环境下，用c语言编写的关于mmap使用方法的小程序
利用mmap实现文件拷贝功能
08-25
利用mmap实现文件拷贝功能 利用mmap实现文件拷贝功能是指使用mmap系统调用来实现文件拷贝功能。mmap是一种 memory-mapped file 机制，允许程序直接访问磁盘文件，而不需要使用标准的文件I/O操作。这种机制可以提高...
mmap实验源文件源文件实现
11-09
内存映射（mmap）是Linux操作系统中的一种内存管理机制，允许进程将文件或设备的存储区域直接映射到其虚拟地址空间。这种方式使得进程可以直接通过指针访问文件内容，而无需通过系统调用来读写文件，提高了I/O效率。...
nanopi m1关于mmap对gpio进行控制
12-07
"nanopi m1关于mmap对gpio进行控制"这个主题聚焦于如何利用mmap函数在用户空间直接操控GPIO，以实现对硬件设备如LED的控制。这里我们将详细讨论mmap、GPIO以及如何在用户空间控制GPIO。 1. **mmap（Memory Mapped I...
Fc2视频被区域限制怎么办
08-08
Fc2视频被区域限制怎么办
use-mmap-method.zip_mmap_space
09-14
标题中的"use-mmap-method.zip_mmap_space"表明这是一个关于使用内存映射文件（Memory-Mapped File，简称mmap）技术的压缩包，主要探讨如何将文件写入内存空间。描述提到“use mmap method to write a file to own ...
mmap2mm mmap2mm mmap2mm
01-05
mmap2mm 工具包 解压python.mmap到目录下，然后使用如下工具转换解压缩目录里的Document.xml xsltproc.exe -o test.mm mm2fm.xslt Document.xml 生成的test.mm 就是目标freemind格式的mm文件
mmap:节点mmap实施
05-06
内存保护： mmap.PROT_NONE或mmap.PROT_READ ， mmap.PROT_WRITE和mmap.PROT_EXEC的按位“或”。 标志 标志： mmap.MAP_SHARED或mmap.MAP_PRIVATE 。 fd 文件描述符。 您也可以使用文件名（字符串）。 当您执行此...
mmap-go:Go的便携式mmap软件包
04-13
mmap-go mmap-go是用于的便携式mmap软件包。 它已经在Linux（386，amd64），OS X和Windows（386）上进行了测试。 它也应该可以在其他类似Unix的平台上运行，但尚未经过测试。 我很想知道结果。 我无法在不增加大量...
Python制作词云视频(使用B站视频及弹幕文本)
黑白的黒's Blog
04-17 1万+
Python制作词云视频-目录使用到的第三方库项目思路&代码流程B站弹幕爬取思路实现 使用到的第三方库 Package Version --------------- --------- baidu-aip 2.2.18.0 jieba 0.42.1 moviepy 1.0.3 numpy 1.20.2 opencv-python 4.5.1.48 Pillow 8.2.0 requests
FC22录屏工具
qq_42108501的博客
09-26 1万+
Linux FC22 屏幕录制工具 在Linux系统中有很多优秀的屏幕的录制工具，比如： 1.SimpleScreenRecorder SimpleScreenRecorder是一个应用程序，使您可以记录其他的应用程序和你的屏幕上运行的游戏。这是一个简单但功能强大，功能丰富的屏幕记录软件，包括一个易于使用的界面。 安装和使用阅读: http://www.tecmint.com/screencasting-with-simple-screen-recorder-in-linux 它的一些显著特点包括: 基于Q
网络资源下载链接分享6
qq_25467549的博客
12-14 1836
精心整理了一份资源，在此与大家分享：                精通ANDROID UI设计 链接：https://pan.baidu.com/s/1TUCJxgLgSgXW6dfgMQj9GA  提取码：fwls   
使用卷积层替代全连接层（VGG16网络，keras）
zh_JNU的博客
12-16 1万+
    前段时间校招面试的问题有一个就是如何使用卷积层来替代全连接层。以前没有认真考虑过，所以第一时间的想法是1×1的卷积核去实现。后来仔细想一想，1×1卷积核并不能实现这样的功能，涉及到参数共享。昨天，看到PixelLink文字定位网络，该网络使用了VGG网络的全连接层。所以就想着今天使用keras实现下VGG16网络卷积层替换全连接层。参数还是依然使用预训练参数，最后保存参数。查看对比.h5文...
ModelMap mmap
最新发布
09-28
ModelMap是Pandas库中的一个功能，它不是一个单独的函数或类名，而是DataFrame对象的一个属性，用于存储DataFrame中列的映射。当DataFrame有大量重复的列名时，ModelMap可以帮助管理这些重复的列名，并且每个列名都可以关联到DataFrame实际的数据位置。 例如，如果你有一个DataFrame，其中包含两列都叫做"ID"，你可以通过ModelMap将这两个列分别标记为原始的"ID_1"和"ID_2"： ```python import pandas as pd df = pd.DataFrame({'ID_1': [1, 2, 3], 'Name': ['Alice', 'Bob', 'Charlie'], 'ID_2': [4, 5, 6]}) # 使用ModelMap mmap = df._mgr.models_map print(mmap) # 输出类似：{'ID_1': <Int64Index ...>, 'ID_2': <Int64Index ...>} # 访问特定列的实际位置 id_column_index = mmap['ID_1'] print(df.iloc[:, id_column_index]) # 输出： ID_1 # 0 1 # 1 2 # 2 3 ``` ModelMap的作用在于提高DataFrame的操作效率，特别是当进行复杂的数据分析或合并操作时，因为不需要频繁地检查列名的唯一性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值