[转帖]【mmap】深度分析mmap：是什么 为什么 怎么用 性能总结

mmap,深度,分析,什么,为什么,怎么,性能,总结 · 浏览次数 : 0

小编点评

## mmap()函数效率对比分析 **分析内容:** * 这里应用了网上一篇文章的分析，着这里引用一下。 * #include <stdio.h> * #include <stdlib.h> * #include <sys/types.h> * #include <sys/stat.h> * #include <unistd.h> * #include <sys/mman.h> **效率对比分析:** * 这里应用了网上一篇文章的分析，着这里引用一下。 * 发现较好的分析，着这里引用一下。 **#include <stdio.h>** * 这里使用了stdio库的函数，包括**#include <stdio.h>****，使可以使用printf()等函数进行效率分析。 **#include <stdlib.h>** * 这里使用了stdlib库的函数，包括**#include <stdlib.h>****，使可以使用**rand()**等函数进行效率分析。 **#include <sys/types.h>** * 这里使用了sys库的类型定义，包括**#include <sys/types.h>****，使可以使用**int**、**float**等类型进行效率分析。 **#include <sys/stat.h>** * 这里使用了sys库的类型定义，包括**#include <sys/stat.h>****，使可以使用**stat**等函数进行效率分析。 **#include <unistd.h>** * 这里使用了unistd库的函数，包括**#include <unistd.h>****，使可以使用**open()**、**read()**等函数进行效率分析。 **#include <sys/mman.h>** * 这里使用了sys库的函数，包括**#include <sys/mman.h>****，使可以使用**mmap()**等函数进行效率分析。 **效率分析方法:** * 使用**fstat()**等函数获取文件大小和偏移量。 * 使用**mmap()**等函数进行文件映射。 * 使用**printf()**等函数进行效率分析。 * 使用**rand()**等函数进行效率分析。 **效率优化的原因:** * mmap()函数开销很大，尤其是对文件的打开、映射和读写操作。 * 使用mmap()函数时，需要进行**pagefault**处理，页面大小通常为**1024**字节。 * mmap()函数没有**LRU**机制，页面可能在内存中分配不连续的区域。 * mmap()函数没有**读操作缓存**，每次读操作都需要从磁盘读取数据。 **结论:** * mmap()函数效率比较低，尤其是对文件的打开、映射和读写操作。 * 使用mmap()函数时，需要进行**pagefault**处理，页面大小通常为**1024**字节。 * mmap()函数没有**LRU**机制，页面可能在内存中分配不连续的区域。

正文

https://blog.csdn.net/bandaoyu/article/details/106750990

目录

有什么用？

1、文件映射

2、分配内存（匿名文件映射）

mmap基础概念

mmap内存映射原理

mmap和常规文件操作的区别

mmap优点总结

 mmap相关函数

mmap使用细节

性能总结

效率对比 

有什么用？

将一个文件或者其它对象映射到进程的地址空间，这样的映射后，进程就可以采用指针的方式读写操作这一段内存，而系统会自动回写脏页面到对应的文件磁盘上，即完成了对文件的操作而不必再调用read,write等系统调用函数。反之，内核空间对这段区域的修改也直接反映用户空间，从而可以实现不同进程间的文件共享。
 

1、文件映射

gcc mmap.c -o mmaptest

示例：

  1. /*******************************************************************
  2.  *   > File Name: mmap.c
  3.  *   > Create Time: 2021年09月28日 星期二 19时30分22秒
  4.  ******************************************************************/
  5. #include <stdio.h>
  6. #include <sys/types.h>
  7. #include <sys/stat.h>
  8. #include <fcntl.h>
  9. #include <unistd.h>
  10. #include <sys/mman.h>
  11.  
  12. int main(int argc, char* argv[])
  13. {
  14.     int fd;
  15.     void *start;
  16.     struct stat sb;
  17.  
  18.     fd = open("test.txt", O_RDONLY); // 打开文件test.txt
  19.     fstat(fd, &sb); // 获取文件状态
  20.     start = mmap(NULL, sb.st_size, PROT_READ, MAP_PRIVATE, fd, 0); // 建立内存映射
  21.     if(start == MAP_FAILED){
  22.         return (-1);
  23.     }
  24.  
  25.     printf("%s\n", (char*)start); // 输出内存内容
  26.     munmap(start, sb.st_size); // 解除内存映射
  27.     close(fd); // 关闭文件
  28.  
  29.     return 0;
  30. }

linux mmap使用例子-wallwind-ChinaUnix博客

  1. int main(int argc, char **argv)　　
  2. {
  3. 　　int fd;
  4. 　　char *mapped_mem, * p;
  5. 　　int flength = 1024;
  6. 　　void * start_addr = 0;
  7. 　　fd = open(argv[1], O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
  8. 　　flength = lseek(fd, 1, SEEK_END);
  9. 　　write(fd, "\0", 1); /* 在文件最后添加一个空字符，以便下面printf正常工作 */
  10. 　　lseek(fd, 0, SEEK_SET);
  11. 　　mapped_mem = mmap(start_addr, flength, PROT_READ, //允许读
  12. 　　MAP_PRIVATE, //不允许其它进程访问此内存区域
  13. 　　fd, 0);
  14. 　　/* 使用映射区域. */
  15. 　　printf("%s\n", mapped_mem); /* 为了保证这里工作正常，参数传递的文件名最好是一个文本文件 */
  16. 　　close(fd);
  17. 　　munmap(mapped_mem, flength);
  18. 　　return 0;
  19.  
  20. }

2、分配内存（匿名文件映射）

使用例子

  1.    /* Allocate some space and setup a DMA mapping */                                       
  2.     dma_map.vaddr = mmap(0, 1024 * 1024, PROT_READ | PROT_WRITE,        
  3.                  MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);                    // 分配1M内存
  4.     dma_map.size  = 1024 * 1024;                                                           
  5.     dma_map.iova  = 0; /* 1MB starting at 0x0 from device view */        
  6.     dma_map.flags = VFIO_DMA_MAP_FLAG_READ | VFIO_DMA_MAP_FLAG_WRITE;   

说明
  使用 mmap 时， fd 为0， FLGA 为 MAP_ANONYMOUS，相当于用来分配一个匿名文件对应的内存出来，也就是分配内存

 使用mmap进行内存分配，主要是用于比较大的内存

  1. //mmap.c
  2. #include <stdio.h>
  3. #include <sys/mman.h>
  4. #include <stdlib.h>
  5. #include <string.h>
  6.  
  7. int main()
  8. {
  9.    /*映射一片内存*/
  10.    void* p = mmap(0,//让系统指定映射内存的首地址(虚拟地址)
  11.         4,//映射4bytes的空间，其实会映射一页内存
  12.         PROT_READ|PROT_WRITE,//权限，有读写权限
  13.         MAP_PRIVATE|MAP_ANONYMOUS,/*MAP_ANONYMOUS:匿名映射，当映射到内存时，只能使用匿名映射。MAP_SHARED和MAP_PRIVATE必选其一。*/ 
  14.         0,//文件描述符，用于映射到文件，内存映射中会忽略
  15.         0);//文件偏移量，用于文件，内存映射也会忽略
  16.    if(p==MAP_FAILED){
  17.       perror("映射失败");
  18.       exit(-1);
  19.    }
  20.    int* pi = p+500;
  21.    int i;
  22.    for(i=10; i<60; i++){
  23.       pi[i] = i;  
  24.    }
  25.    strcpy(p+750, "ABCDEFGHIJKLMN");
  26.    char* pc = p;
  27.    for(i=0; i<800; i++){
  28.       if(i%10==0)printf("\n");
  29.       printf("%x ", pc[i]);
  30.    }
  31.    printf("p=%p\n", p);
  32.    sleep(20);
  33.    munmap(p, 4);
  34.   // while(1);
  35. }

mmap基础概念

mmap是一种内存映射文件的方法，即将一个文件或者其它对象映射到进程的地址空间，实现文件磁盘地址和进程虚拟地址空间中一段虚拟地址的一一对映关系。实现这样的映射关系后，进程就可以采用指针的方式读写操作这一段内存，而系统会自动回写脏页面到对应的文件磁盘上，即完成了对文件的操作而不必再调用read,write等系统调用函数。相反，内核空间对这段区域的修改也直接反映用户空间，从而可以实现不同进程间的文件共享。如下图所示：

由上图可以看出，进程的虚拟地址空间，由多个虚拟内存区域构成。虚拟内存区域是进程的虚拟地址空间中的一个同质区间，即具有同样特性的连续地址范围。上图中所示的text数据段（代码段）、初始数据段、BSS数据段、堆、栈和内存映射，都是一个独立的虚拟内存区域。而为内存映射服务的地址空间处在堆栈之间的空余部分。

linux内核使用vm_area_struct结构来表示一个独立的虚拟内存区域，由于每个不同质的虚拟内存区域功能和内部机制都不同，因此一个进程使用多个vm_area_struct结构来分别表示不同类型的虚拟内存区域。各个vm_area_struct结构使用链表或者树形结构链接，方便进程快速访问，如下图所示：

vm_area_struct结构中包含区域起始和终止地址以及其他相关信息，同时也包含一个vm_ops指针，其内部可引出所有针对这个区域可以使用的系统调用函数。这样，进程对某一虚拟内存区域的任何操作需要用要的信息，都可以从vm_area_struct中获得。mmap函数就是要创建一个新的vm_area_struct结构，并将其与文件的物理磁盘地址相连。具体步骤请看下一节。

mmap内存映射原理

mmap内存映射的实现过程，总的来说可以分为三个阶段：

（一）进程启动映射过程，并在虚拟地址空间中为映射创建虚拟映射区域

1、进程在用户空间调用库函数mmap，原型：void *mmap(void *start, size_t length, int prot, int flags, int fd, off_t offset);

2、在当前进程的虚拟地址空间中，寻找一段空闲的满足要求的连续的虚拟地址

3、为此虚拟区分配一个vm_area_struct结构，接着对这个结构的各个域进行了初始化

4、将新建的虚拟区结构（vm_area_struct）插入进程的虚拟地址区域链表或树中

（二）调用内核空间的系统调用函数mmap（不同于用户空间函数），实现文件物理地址和进程虚拟地址的一一映射关系

5、为映射分配了新的虚拟地址区域后，通过待映射的文件指针，在文件描述符表中找到对应的文件描述符，通过文件描述符，链接到内核“已打开文件集”中该文件的文件结构体（struct file），每个文件结构体维护着和这个已打开文件相关各项信息。

6、通过该文件的文件结构体，链接到file_operations模块，调用内核函数mmap，其原型为：int mmap(struct file *filp, struct vm_area_struct *vma)，不同于用户空间库函数。

7、内核mmap函数通过虚拟文件系统inode模块定位到文件磁盘物理地址。

8、通过remap_pfn_range函数建立页表，即实现了文件地址和虚拟地址区域的映射关系。此时，这片虚拟地址并没有任何数据关联到主存中。

（三）进程发起对这片映射空间的访问，引发缺页异常，实现文件内容到物理内存（主存）的拷贝

注：前两个阶段仅在于创建虚拟区间并完成地址映射，但是并没有将任何文件数据的拷贝至主存。真正的文件读取是当进程发起读或写操作时。

9、进程的读或写操作访问虚拟地址空间这一段映射地址，通过查询页表，发现这一段地址并不在物理页面上。因为目前只建立了地址映射，真正的硬盘数据还没有拷贝到内存中，因此引发缺页异常。

10、缺页异常进行一系列判断，确定无非法操作后，内核发起请求调页过程。

11、调页过程先在交换缓存空间（swap cache）中寻找需要访问的内存页，如果没有则调用nopage函数把所缺的页从磁盘装入到主存中。

12、之后进程即可对这片主存进行读或者写的操作，如果写操作改变了其内容，一定时间后系统会自动回写脏页面到对应磁盘地址，也即完成了写入到文件的过程。

注：修改过的脏页面并不会立即更新回文件中，而是有一段时间的延迟，可以调用msync()来强制同步, 这样所写的内容就能立即保存到文件里了。

mmap和常规文件操作的区别

对linux文件系统不了解的朋友，请参阅我之前写的博文《从内核文件系统看文件读写过程》，我们首先简单的回顾一下常规文件系统操作（调用read/fread等类函数）中，函数的调用过程：

1、进程发起读文件请求。

2、内核通过查找进程文件符表，定位到内核已打开文件集上的文件信息，从而找到此文件的inode。

3、inode在address_space上查找要请求的文件页是否已经缓存在页缓存中。如果存在，则直接返回这片文件页的内容。

4、如果不存在，则通过inode定位到文件磁盘地址，将数据从磁盘复制到页缓存。之后再次发起读页面过程，进而将页缓存中的数据发给用户进程。

总结来说，常规文件操作为了提高读写效率和保护磁盘，使用了页缓存机制。这样造成读文件时需要先将文件页从磁盘拷贝到页缓存中，由于页缓存处在内核空间，不能被用户进程直接寻址，所以还需要将页缓存中数据页再次拷贝到内存对应的用户空间中。这样，通过了两次数据拷贝过程，才能完成进程对文件内容的获取任务。写操作也是一样，待写入的buffer在内核空间不能直接访问，必须要先拷贝至内核空间对应的主存，再写回磁盘中（延迟写回），也是需要两次数据拷贝。

而使用mmap操作文件中，创建新的虚拟内存区域和建立文件磁盘地址和虚拟内存区域映射这两步，没有任何文件拷贝操作。而之后访问数据时发现内存中并无数据而发起的缺页异常过程，可以通过已经建立好的映射关系，只使用一次数据拷贝，就从磁盘中将数据传入内存的用户空间中，供进程使用。

总而言之，常规文件操作需要从[磁盘]到[页缓存]再到[用户主存]的两次数据拷贝。而mmap操控文件，只需要从[磁盘]到[用户主存]的一次数据拷贝过程。说白了，mmap的关键点是实现了用户空间和内核空间的数据直接交互而省去了空间不同数据不通的繁琐过程。因此mmap效率更高。

mmap优点总结

由上文讨论可知，mmap优点共有一下几点：

1、对文件的读取操作跨过了页缓存，减少了数据的拷贝次数，用内存读写取代I/O读写，提高了文件读取效率。

2、实现了用户空间和内核空间的高效交互方式。两空间的各自修改操作可以直接反映在映射的区域内，从而被对方空间及时捕捉。

3、提供进程间共享内存及相互通信的方式。不管是父子进程还是无亲缘关系的进程，都可以将自身用户空间映射到同一个文件或匿名映射到同一片区域。从而通过各自对映射区域的改动，达到进程间通信和进程间共享的目的。

     同时，如果进程A和进程B都映射了区域C，当A第一次读取C时通过缺页从磁盘复制文件页到内存中；但当B再读C的相同页面时，虽然也会产生缺页异常，但是不再需要从磁盘中复制文件过来，而可直接使用已经保存在内存中的文件数据。

4、可用于实现高效的大规模数据传输。内存空间不足，是制约大数据操作的一个方面，解决方案往往是借助硬盘空间协助操作，补充内存的不足。但是进一步会造成大量的文件I/O操作，极大影响效率。这个问题可以通过mmap映射很好的解决。换句话说，但凡是需要用磁盘空间代替内存的时候，mmap都可以发挥其功效。

 mmap相关函数

函数原型

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

返回说明

成功执行时，mmap()返回被映射区的指针。失败时，mmap()返回MAP_FAILED[其值为(void *)-1]， error被设为以下的某个值：

 返回错误类型

参数

start：映射区的开始地址

length：映射区的长度

prot：期望的内存保护标志，不能与文件的打开模式冲突。是以下的某个值，可以通过or运算合理地组合在一起

 prot

flags：指定映射对象的类型，映射选项和映射页是否可以共享。它的值可以是一个或者多个以下位的组合体

 flag

fd：有效的文件描述词。如果MAP_ANONYMOUS被设定，为了兼容问题，其值应为-1

offset：被映射对象内容的起点

相关函数

int munmap( void * addr, size_t len ) 

成功执行时，munmap()返回0。失败时，munmap返回-1，error返回标志和mmap一致；

该调用在进程地址空间中解除一个映射关系，addr是调用mmap()时返回的地址，len是映射区的大小；

当映射关系解除后，对原来映射地址的访问将导致段错误发生。 

int msync( void *addr, size_t len, int flags )

一般说来，进程在映射空间的对共享内容的改变并不直接写回到磁盘文件中，往往在调用munmap（）后才执行该操作。

可以通过调用msync()实现磁盘上文件内容与共享内存区的内容一致。

mmap使用细节

1、使用mmap需要注意的一个关键点是，mmap映射区域大小必须是物理页大小(page_size)的整倍数（32位系统中通常是4k字节）。原因是，内存的最小粒度是页，而进程虚拟地址空间和内存的映射也是以页为单位。为了匹配内存的操作，mmap从磁盘到虚拟地址空间的映射也必须是页。

2、内核可以跟踪被内存映射的底层对象（文件）的大小，进程可以合法的访问在当前文件大小以内又在内存映射区以内的那些字节。也就是说，如果文件的大小一直在扩张，只要在映射区域范围内的数据，进程都可以合法得到，这和映射建立时文件的大小无关。具体情形参见“情形三”。

3、映射建立之后，即使文件关闭，映射依然存在。因为映射的是磁盘的地址，不是文件本身，和文件句柄无关。同时可用于进程间通信的有效地址空间不完全受限于被映射文件的大小，因为是按页映射。

在上面的知识前提下，我们下面看看如果大小不是页的整倍数的具体情况：

情形一：一个文件的大小是5000字节，mmap函数从一个文件的起始位置开始，映射5000字节到虚拟内存中。

分析：因为单位物理页面的大小是4096字节，虽然被映射的文件只有5000字节，但是对应到进程虚拟地址区域的大小需要满足整页大小，因此mmap函数执行后，实际映射到虚拟内存区域8192个 字节，5000~8191的字节部分用零填充。映射后的对应关系如下图所示：

此时：

（1）读/写前5000个字节（0~4999），会返回操作文件内容。

（2）读字节5000~8191时，结果全为0。写5000~8191时，进程不会报错，但是所写的内容不会写入原文件中 。

（3）读/写8192以外的磁盘部分，会返回一个SIGSECV错误。

情形二：一个文件的大小是5000字节，mmap函数从一个文件的起始位置开始，映射15000字节到虚拟内存中，即映射大小超过了原始文件的大小。

分析：由于文件的大小是5000字节，和情形一一样，其对应的两个物理页。那么这两个物理页都是合法可以读写的，只是超出5000的部分不会体现在原文件中。由于程序要求映射15000字节，而文件只占两个物理页，因此8192字节~15000字节都不能读写，操作时会返回异常。如下图所示：

此时：

（1）进程可以正常读/写被映射的前5000字节(0~4999)，写操作的改动会在一定时间后反映在原文件中。

（2）对于5000~8191字节，进程可以进行读写过程，不会报错。但是内容在写入前均为0，另外，写入后不会反映在文件中。

（3）对于8192~14999字节，进程不能对其进行读写，会报SIGBUS错误。

（4）对于15000以外的字节，进程不能对其读写，会引发SIGSEGV错误。

情形三：一个文件初始大小为0，使用mmap操作映射了1000*4K的大小，即1000个物理页大约4M字节空间，mmap返回指针ptr。

分析：如果在映射建立之初，就对文件进行读写操作，由于文件大小为0，并没有合法的物理页对应，如同情形二一样，会返回SIGBUS错误。

但是如果，每次操作ptr读写前，先增加文件的大小，那么ptr在文件大小内部的操作就是合法的。例如，文件扩充4096字节，ptr就能操作ptr ~ [ (char)ptr + 4095]的空间。只要文件扩充的范围在1000个物理页（映射范围）内，ptr都可以对应操作相同的大小。

这样，方便随时扩充文件空间，随时写入文件，不造成空间浪费

性能总结

大家关于“mmap()”更快的认识来自于read() 是需要内存拷贝的；

当今硬件技术的发展，使得内存拷贝消耗的时间已经极大降低了；

但“mmap()”的开销在于一次  pagefault，这个开销相比而言已经更高了，而且 pagefault 的处理任务现在比以前还更多了；

而且，mmap之后，再有读操作不会经过系统调用，在 LRU 比较最近使用的页的时候不占优势；

于是，普通读情况下（排除反复读之类的文艺与2B读操作），read() 通常会比mmap() 来得更快。




转自链接：https://www.jianshu.com/p/56da33b287dd

效率对比 

效率对比：

    这里应用了网上一篇文章。发现较好的分析，着这里引用一下。

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <sys/types.h>
  4. #include <sys/stat.h>
  5. #include <unistd.h>
  6. #include <sys/mman.h>
  7.  
  8. void main()
  9. {
  10.  
  11.     int fd = open("test.file", 0);
  12.     struct stat statbuf;
  13.     char *start;
  14.     char buf[2] = {0};
  15.     int ret = 0;
  16.  
  17.     fstat(fd, &statbuf);
  18.     start = mmap(NULL, statbuf.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
  19.  
  20.     do
  21.     {
  22.         *buf = start[ret++];
  23.     }
  24.     while(ret < statbuf.st_size);
  25. }
  26.  
  27. Read：
  28.  
  29. #include <stdio.h>
  30. #include <stdlib.h>
  31.  
  32. void main()
  33. {
  34.  
  35.     FILE *pf = fopen("test.file", "r");
  36.     char buf[2] = {0};
  37.     int ret = 0;
  38.  
  39.     do
  40.     {
  41.         ret = fread(buf, 1, 1, pf);
  42.  
  43.     }
  44.     while(ret);
  45. }
  46.

mmap 深度 分析 什么 为什么 怎么 性能 总结

与[转帖]【mmap】深度分析mmap：是什么 为什么 怎么用 性能总结相似的内容：

[转帖]【mmap】深度分析mmap：是什么 为什么 怎么用 性能总结

`https://blog.csdn.net/bandaoyu/article/details/106750990` 目录 有什么用？ 1、文件映射 2、分配内存（匿名文件映射） mmap基础概念 mmap内存映射原理 mmap和常规文件操作的区别 mmap优点总结 mmap相关函数 mmap使用细

mmap 深度 分析 什么
0
[转帖]writeback mmap-ed dirty page

https://zhuanlan.zhihu.com/p/517122285 问题 文件系统接口写脏的page cache, 因为主动调用了syscall, os知道该dirty page并在inode上进行标记, 之后合适的时间会进行writeback, 那么对于mmap后直接对地址进行写的数据,

writeback mmap ed dirty
0
[转帖]sendfile“零拷贝”、mmap内存映射、DMA

https://www.jianshu.com/p/7863667d5fa7 KAFKA推送消息用到了sendfile，落盘技术用到了mmap，DMA贯穿其中。 先说说零拷贝 零拷贝并不是不需要拷贝，而是减少不必要的拷贝次数。通常是说在IO读写过程中。 实际上，零拷贝是有广义和狭义之分，目前我们通常

sendfile 拷贝 mmap 内存
0
[转帖]Linux中的零拷贝技术

https://www.jianshu.com/p/a757a93b6e5f 内存映射--mmap 内核和用户空间，共享内存。数据copy到内核区后，只需要把地址共享给应用程序即可，无需再copy一次数据到用户空间。 image.png 优点： 用户程序可以读取和修改共享内存的数据，就像读取用户空间

linux 拷贝 技术
0
[转帖]fio 命令入门到跑路

fio是一种I / O工具，用于基准测试和压力/硬件验证。它支持19种不同类型的I / O引擎（sync，mmap，libaio，posixaio，SG v3，splice，null，network，syslet，guasi，solarisaio等），I / O优先级（适用于较新的Linux内核）

fio 命令 入门
0
[转帖]linux中 vm.overcommit_memory 的含义

https://www.cnblogs.com/wshenjin/p/15500202.html vm.overcommit_memory 表示内核在分配内存时候做检查的方式。这个变量可以取到0,1,2三个值。对取不同的值时的处理方式都定义在内核源码 mm/mmap.c 的 __vm_enough_

linux vm overcommit memory
0
[转帖]【详细齐全】FIO使用方法 及参数解析（文章末尾）

linux 使用FIO测试磁盘iops 方法详解 FIO是测试IOPS的非常好的工具，用来对硬件进行压力测试和验证，支持13种不同的I/O引擎， 包括:sync,mmap, libaio, posixaio, SG v3, splice, null, network, syslet, guasi,

详细 齐全 fio 使用
0
[转帖]MALLOC_ARENA_MAX=1 与 MALLOC_ARENA_MAX=4有什么区别？

https://www.easyice.cn/archives/341 2019年 Elastic开发者大会的时候我曾经说过 glibc 导致的堆外内存过多问题： 如果应用程序每次分配内存的时候都通过系统调用 mmap，sbrk等来分配，效率会很低，所以glibc 中实现了一个内存池，应用程序使用内

malloc arena max 什么
0
[转帖]文件系统读写性能fio测试方法及参数详解

简介 Fio 是一个 I/O 工具，用来对硬件进行压力测试和验证，磁盘IO是检查磁盘性能的重要指标，可以按照负载情况分成照顺序读写，随机读写两大类。 Fio支持13种不同的I/O引擎，包括：sync, mmap, libaio, posixaio, SG v3, splice, null, netw

文件系统 读写 性能 fio
0
[转帖]

Linux ubuntu20.04 网络配置（图文教程） 因为我是刚装好的最小系统，所以很多东西都没有，在开始配置之前需要做下准备 环境准备 系统：ubuntu20.04网卡：双网卡 网卡一：供连接互联网使用网卡二：供连接内网使用（看情况，如果一张网卡足够，没必要做第二张网卡） 工具： net-to

0
# 热门排行
微软 New Bing AI 申请与使用保姆级教程（免魔法） ChatGPT API使用介绍 ChatGPT开发实战 一篇带你了解如何使用纯前端类Excel表格构建现金流量表 手把手教你玩转 Excel 数据透视表 为什么 C# 可能是最好的第一编程语言 .NET 入门到高级路线 提高工作效率的神器：基于前端表格实现Chrome Excel扩展插件 React + Springboot + Quartz，从0实现Excel报表自动化 用Echarts实现前端表格引用从属关系可视化
© PmDaddy. 2023 PmDaddy教程网 All rights reserved.