Linux系统编程 --- 共享内存及内存映射【十全十美】

简介:

 一.POSIX共享内存的实现

-----------------------------------------------------------------------------
    共享内存是在进程间共享某一块内存。是最快一种ipc通信机构。其中posix共享内存机制 它主要是通过内存映射(mmap)机制来实现的。
在进程间共享内存使用如下固定步骤:
    1.创建一个共享内存
        int shm_open(const char *name, int oflag, mode_t mode);
            name是共享内存名字,各个进程通过名字来找到同一块内存.
            oflag,是这个内存属性。类似于文件属性。使用O_RDWR/O_RDONLY/O_CREAT,第一次创建共享内存必须带O_CREAT标志位。
            mode,是权限代码。
         当其打开成功是会在建立一个虚拟的文件 /dev/shm/shm.XXXX,其中XXXX是name的名字
        例: int fd = shm_open("test",O_RDWR,666);
          将会创建 /dev/shm/shm.test文件。
        shm_open成功后,将返回一个文件描述符fd.你可以理解是在内核的中分配一段空间,并分配一个fd号给应用程序使用。
       这里要注意,如果一个进程已经创建一个共享内存,后面其它的进程打开这个共享内存只需要用
      shm_open(name,flag,0); //而且    
   2.设置内存大小。
         int ftruncate(int fd, off_t length);
      ftruncate操作的fd即可是一个文件open后的fd,也可是shm_open打开的fd  .
         普通文件将会被ftruncate强行设为length大小(不够加0空间,超过则被截断
       如果共享内存,将表示把共享内存设为length大小.
       如果设置 ftruncate返回0
 
  3.用mmap 眏射到进程空间当中某一个地址上
       void *mmap(void *start, size_t length, int prot, int flags,
                  int fd, off_t offset);
 
          start是表示开始映射的物理地址,如果为NULL表示由内核自行选择合适空间来分配。
          length是内存的大小,一般是和第二步的同一大小。
          prot 是共享内存属性。它有如下值
                 PROT_EXEC 分配空间可执行
                 PROT_READ 分配空间可读
                 PROT_WRITE 可写
                 PROT_NONE 禁止访问,一般为省事,都设为  PROT_READ|PROT_WRITE
          flags 是共享内存的标志位,它有如下取值
                 MAP_FIXED ,内存固定大小,不能超过一页。如果超过将mmap失败.
                  MAP_SHARED ,在多个进程间共享这一内存
                  MAP_PRIVATE, 只供本进程使用。
          fd 是shm_open或open创建文件的描述符.
          offset 是在共享内存或文件中的偏移量。一般是0
         如果映射成功,将会返回一个进程内部地址。对这个地址访问即是对内核共享内存的访问。这个地址位于堆和栈的空闲区。
   如果失败,将返回MAP_FAILED (它等于 (void *)-1)
  到mmap后,对共享内存的操作就跟与普通内存没有什么区别了。如使用memcpy/memset等操作.
 
   如果结束的对共享内存使用,即可采用接下两步.
4.munmap解除当前进程对这块共享映射。
     int munmap(void *start, size_t length); 
  start是映射的进程内地址,lenght是内存的长度
   如果映射是文件,它还有存盘功能。
 
 5.从内核清除共享内存
      int shm_unlink(const char *name);
    name是共享内存名字,如果有多个进程打开这个内存,只有最后使用进程调用shm_unlink,这个共享内存才会真正清除掉。
   
 
  
                
 二.POSIX共享内存实现代码
---------------------------------------------------------------------------
 
 
 
  1. #include <unistd.h> 
  2. #include <sys/types.h> 
  3. #include <sys/stat.h> 
  4. #include <fcntl.h> 
  5.  
  6. #include <signal.h> 
  7.  
  8.  
  9. #include <sys/mman.h> /* for mmap,shm_open */ 
  10. #include <string.h> 
  11.  
  12. #include <stdio.h> 
  13. #include <stdlib.h> 
  14. #include <errno.h> 
  15.  
  16.  
  17. #define PRINT_INTX(e) printf("%s=0x%X\n",#e,e) 
  18.  
  19.  
  20. typedef struct mmap_fd{ 
  21.    int fd; /* 打开后的文件描述符*/ 
  22.    void * base; /* 在进程内部的地址*/ 
  23.    char * name; /* 共享内存名字 */ 
  24.     int len ; /* 共享内存长度 */ 
  25.     int offset; /* fd中的偏移量*/ 
  26. }MMAP_FD; 
  27.  
  28.  
  29. #define MMAP_ADDR(p) (p)->base 
  30.  
  31.  
  32. MMAP_FD * shm_map(char * name,int len,int offset) 
  33.    MMAP_FD * p_fd; 
  34.    void * base; 
  35.  
  36.    int fd; 
  37.      
  38.   //第一步:创建一个共享内存 
  39.  
  40.     fd = shm_open(name,O_CREAT|O_EXCL|O_RDWR,666); 
  41.      if(fd == -1) 
  42.       { 
  43.          if(errno == EEXIST) 
  44.             { 
  45.               fd = shm_open(name,O_RDWR,666); 
  46.              } 
  47.       } 
  48.  
  49.    
  50.    if(fd == -1) 
  51.        { 
  52.          perror("shm_open"); 
  53.        return NULL; 
  54.        } 
  55.  
  56.     //第二步:设置内存大小 
  57.  
  58.       if(ftruncate(fd,len) == -1) 
  59.           { 
  60.                  perror("ftruncate"); 
  61.                shm_unlink(name); 
  62.                return NULL; 
  63.           } 
  64.  
  65.     //第三步,将内核中共享内存映射到进程空间之上 
  66.  
  67.   //void *mmap(void *start, size_t length, int prot, int flags, 
  68.  
  69. // int fd, off_t offset); 
  70.  
  71.       base = mmap(NULL,len,PROT_READ | PROT_WRITE, MAP_SHARED ,fd,offset); 
  72.        if(base == MAP_FAILED) 
  73.         { 
  74.              perror("mmap"); 
  75.              shm_unlink(name); 
  76.               return NULL; 
  77.          } 
  78.         
  79.  
  80.         p_fd = malloc(sizeof(MMAP_FD)); 
  81.          p_fd->len = len; 
  82.          p_fd->name = strdup(name); 
  83.          p_fd->fd = fd; 
  84.          p_fd->base = base; 
  85.          p_fd->offset = offset; 
  86.  
  87.     return p_fd; 
  88.      
  89.  
  90.  
  91. int shm_destroy(MMAP_FD * p_fd) 
  92.    if(p_fd == NULL) 
  93.       return -1; 
  94.    //取消映射 
  95.  
  96.    if(munmap(p_fd->base,p_fd->len) == -1) 
  97.       { 
  98.           perror("munmap"); 
  99.            return -1; 
  100.       } 
  101.  
  102.    //删除共享内存 
  103.  
  104.     if(shm_unlink(p_fd->name) == -1) 
  105.       { 
  106.            perror("shm_unlink"); 
  107.              return -2; 
  108.       } 
  109.  
  110.    free(p_fd->name); 
  111.    free(p_fd); 
  112.  
  113.     return 0; 
  114.  
  115.  
  116. #define SHM_NAME "test_mmap" 
  117.  
  118.  MMAP_FD * p_fd = NULL; 
  119.  
  120. void exit_handler(int sig) 
  121.    printf("EXIT HANDLER\n"); 
  122.    shm_destroy(p_fd); 
  123.    exit(0); 
  124.  
  125. //创建进程,用于写数据 
  126.  
  127. void write_proc() 
  128.   
  129.   char ary[10]; 
  130.    char * p ; 
  131.    static int count = 1; 
  132.  
  133.       printf("WRITE SHM\n"); 
  134.  
  135.    signal(SIGINT,exit_handler); 
  136.    signal(SIGTERM,exit_handler); 
  137.      
  138.  
  139.    p_fd = shm_map(SHM_NAME,100,0); 
  140.    if(p_fd == NULL) 
  141.          return ; 
  142.  
  143.     p= malloc(10); 
  144. //注意各种变量地址,ary空间是栈,p是堆的,p_fd->base是内存映射地址 
  145.    PRINT_INTX(ary); 
  146.    PRINT_INTX(MMAP_ADDR(p_fd)); 
  147.  
  148.    PRINT_INTX(p); 
  149.  
  150.    free(p); 
  151.  
  152.  
  153.    while(1) 
  154.     { 
  155.       snprintf(MMAP_ADDR(p_fd),p_fd->len,"mmap write %d\n",count++); 
  156.       sleep(1); 
  157.     } 
  158.  
  159.    
  160.  
  161.  
  162. void read_proc() 
  163.    signal(SIGINT,exit_handler); 
  164.    signal(SIGTERM,exit_handler); 
  165.  
  166.    printf("READ SHM\n"); 
  167.  
  168.    p_fd = shm_map(SHM_NAME,100,0); 
  169.    if(p_fd == NULL) 
  170.          return ; 
  171.  
  172.    while(1) 
  173.     { 
  174.       printf(MMAP_ADDR(p_fd)); 
  175.       sleep(1); 
  176.     } 
  177.  
  178. int main(int argc,char * argv[]) 
  179.    if((argc>1) && (argv[1][0] == 'r')) 
  180.        read_proc(); 
  181.    else 
  182.        write_proc(); 



本文转自 驿落黄昏 51CTO博客,原文链接:http://blog.51cto.com/yiluohuanghun/1081585 ,如需转载请自行联系原作者

目录
打赏
0
0
0
0
348
分享
相关文章
Linux系统资源管理:多角度查看内存使用情况。
要知道,透过内存管理的窗口,我们可以洞察到Linux系统运行的真实身姿,如同解剖学家透过微观镜,洞察生命的奥秘。记住,不要惧怕那些高深的命令和参数,他们只是你掌握系统"魔法棒"的钥匙,熟练掌握后,你就可以骄傲地说:Linux,我来了!
67 27
|
6月前
麒麟系统mate-indicators进程占用内存过高问题解决
【10月更文挑战第7天】麒麟系统mate-indicators进程占用内存过高问题解决
636 2
如何在 Linux 系统中查看进程占用的内存?
如何在 Linux 系统中查看进程占用的内存?
662 58
如何解决 Linux 系统中内存使用量耗尽的问题?
如何解决 Linux 系统中内存使用量耗尽的问题?
388 48
嵌入式Linux系统编程 — 5.3 times、clock函数获取进程时间
在嵌入式Linux系统编程中,`times`和 `clock`函数是获取进程时间的两个重要工具。`times`函数提供了更详细的进程和子进程时间信息,而 `clock`函数则提供了更简单的处理器时间获取方法。根据具体需求选择合适的函数,可以更有效地进行性能分析和资源管理。通过本文的介绍,希望能帮助您更好地理解和使用这两个函数,提高嵌入式系统编程的效率和效果。
156 13
【AI系统】推理内存布局
本文介绍了CPU和GPU的基础内存知识,NCHWX内存排布格式,以及MNN推理引擎如何通过数据内存重新排布进行内核优化,特别是针对WinoGrad卷积计算的优化方法,通过NC4HW4数据格式重排,有效利用了SIMD指令集特性,减少了cache miss,提高了计算效率。
119 3
深入探索Android系统的内存管理机制
本文旨在全面解析Android系统的内存管理机制,包括其工作原理、常见问题及其解决方案。通过对Android内存模型的深入分析,本文将帮助开发者更好地理解内存分配、回收以及优化策略,从而提高应用性能和用户体验。
深入探讨Android系统的内存管理机制
本文将深入分析Android系统的内存管理机制,包括其内存分配、回收策略以及常见的内存泄漏问题。通过对这些方面的详细讨论,读者可以更好地理解Android系统如何高效地管理内存资源,从而提高应用程序的性能和稳定性。
164 16
C 语言在计算机科学中尤其在硬件交互方面占据重要地位。本文探讨了 C 语言与硬件交互的主要方法,包括直接访问硬件寄存器、中断处理、I/O 端口操作、内存映射 I/O 和设备驱动程序开发
C 语言在计算机科学中尤其在硬件交互方面占据重要地位。本文探讨了 C 语言与硬件交互的主要方法,包括直接访问硬件寄存器、中断处理、I/O 端口操作、内存映射 I/O 和设备驱动程序开发,以及面临的挑战和未来趋势,旨在帮助读者深入了解并掌握这些关键技术。
113 6