linux中几种共享内存

最新推荐文章于 2024-02-03 15:39:04 发布

mw_nice

最新推荐文章于 2024-02-03 15:39:04 发布

阅读量2k

点赞数 3

共享内存用处

使用文件或者管道进行进程间通信会有很多局限性。管道只能在父进程和子进程间使用；通过文件共享，在处理效率上又差一些，而且访问文件描述符不如访问内存地址方便。

Linux系统在编程上提供的共享内存方案有三种：

mmap内存共享映射
XSI共享内存
POSIX共享内存

mmap内存共享映射

mmap本来是存储映射功能。它可以将一个文件映射到内存中，在程序里就可以直接使用内存地址对文件内容进行访问。

#include <sys/mman.h>
void *mmap(void *addr, size_t length, int port, int flags, int fd, off_t offset);
int munmap(void *addr, size_t length);

Linux通过系统调用fork派生出的子进程和父进程共用内存地址空间，Linux的mmap实现了一种可以在父子进程之间共享内存地址的方式。

父进程将flags参数设置MAP_SHARED方式通过mmap申请一段内存。内存可以映射某个具体文件（fd），也可以不映射具体文件（fd置为-1，flag设置为MAP_ANONYMOUS）.
父进程调用fork产生子进程，之后在父子进程内都可以访问到mmap所返回的地址，就可以共享内存了。

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
#include <string.h>
#include <sys/file.h>
#include <sys/wait.h>
#include <sys/mman.h>

#define COUNT 100

int do_child(int *count)
{
        int interval;

        // critical section
        interval = *count;
        interval++;
        usleep(1);
        *count = interval;
        // critical section

        exit(0);
}

int main()
{
    pid_t pid;
    int count;
    int *shm_p;

    shm_p = (int *)mmap(NULL, sizeof(int), PROT_WRITE|PROT_READ, MAP_SHARED|MAP_ANONYMOUS, -1, 0);
    if(MAP_FAILED == shm_p) {
        perror("mmap()");
        exit(1);
    }

    *shm_p = 0;

    for(count = 0; count < COUNT; count++) {
        pid = fork();
        if(pid < 0) {
            perror("fork()");
            exit(1);
        }

        if(pid == 0) {
            do_child(shm_p);
        }
    }

    for(count = 0; count < COUNT; count++) {
        wait(NULL);
    }

    printf("shm_p: %d\n", *shm_p);
    munmap(shm_p, sizeof(int));
    exit(0);
}

这段共享内存的使用是有竞争条件的。进程间通信不仅仅是通信这么简单，还要处理类似的这样的临界区代码。在这里，可以采用文件锁进行处理。但是共享内存使用文件锁显得不太协调。除了不方便和效率低下以外，文件锁还不能进行更高级的进程控制。这里可以使用信号量这种更高级的进程同步控制原语来实现相关功能。

下面这段程序用来帮助理解mmap的内存占用情况。

#include<unistd.h>
#include<stdlib.h>
#include<stdio.h>
#include<errno.h>
#include<fcntl.h>
#include<string.h>
#include<sys/file.h>
#include<sys/wait.h>
#include<sys/mman.h>

#define COUNT 100
#define MEMSIZE 1024*1024*1023*2

int main()
{
    pid_t pid;
    int count;
    void *shm_p;

    shm_p = mmap(NULL, MEMSIZE, PROT_WRITE|PROT_READ, MAP_SHARED|MAP_ANONYMOUS, -1, 0);
    if(MAP_FAILED == shm_p) {
        perror("mmap()");
        exit(1);
    }

    bzero(shm_p, MEMSIZE);

    sleep(3000);

    munmap(shm_p, MEMSIZE);
    exit(0);
}

申请了一段近2G的内存，并置0.观察内存变化

[zorro@zorrozou-pc0 sharemem]$ free -g
              total        used        free      shared  buff/cache   available
Mem:             15           2           2           0          10          11
Swap:            31           0          31
[zorro@zorrozou-pc0 sharemem]$ ./mmap_mem &
[1] 32036
[zorro@zorrozou-pc0 sharemem]$ free -g
              total        used        free      shared  buff/cache   available
Mem:             15           2           0           2          12           9
Swap:            31           0          31

可以看出，这段内存被记录到shared和buff/cache中了。

mmap有一个缺点，那就是共享的内存只能在父进程和fork产生的子进程间使用，除此之外的其它进程无法得到共享内存段的地址。

XSI共享内存

XSI是X/Open组织对UNIX定义的一套接口标准（X/Open System Interface）。XSI共享内存在Linux底层的实现实际上跟mmap没有什么本质不同，只是在使用方法上有所区别。

#include<sys/ipc.h>
#include<sys/shm.h>

int shmget(key_t key, size_t size, int shmflg);
int shmctl(int shmid, int cmd, struct shmid_ds *buf);

#include<sys/types.h>
#include<sys/shm.h>

void *shmat(int shmid, const void *shmaddr, int shmflg);
int shmdt(const void *shmaddr);

shmget的第三个参数，指定创建标志。支持的标志为：IPC_CREAT、IPC_EXCL。从Linux 2.6之后，还引入了支持大页的共享内存，标志为：SHM_HUGETLB、SHM_HUGE_2MB等。shemget除了可以创建一个新的共享内存外，还可以访问一个已经存在的内存，此时可以将shmflg置为0，不加任何标志打开。

shmget返回的int类型的shmid类似于文件描述符，注意只是类似，而并非同样的实现，所以，不能用select、poll、epoll这样的方法去控制一个XSI共享内存。对于一个XSI共享内存，其key是系统全局唯一的，这就方便其它进程使用同样的key，打开同样一段共享内存，以便进行进程间通信。而是用fork产生的子进程，可以直接通过shmid访问到相关共享内存段。这就是key的本质：系统中对XSI共享内存的全局唯一表示符。

#include<sys/types.h>
#include<sys/ipc.h>

key_t ftok(const char *pathname, int proj_id);

key是通过ftok函数，使用一个约定好的文件名和proj_id生成的。ftok不会创建文件，所以必须指定一个存在并且进程可以访问的pathname路径。另外，ftok并不是根据文件的路径和文件名生成key的，在具体实现上，它使用的是指定文件的inode编号和文件所在设备的设备编号。所以，不同的文件名也可能得到同一个key（不同的文件名指向同一个inode，硬链接）。同样的文件名也不一定就能得到相同的key，一个文件名有可能被删除重建，这种行为会导致inode变化。

#include<unistd.h>
#include<stdlib.h>
#include<stdio.h>
#include<errno.h>
#include<fcntl.h>
#include<string.h>
#include<sys/file.h>
#include<sys/wait.h>
#include<sys/mman.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<sys/types.h>

#define COUNT 100
#define PATHNAME "/etc/passwd"

int do_child(int proj_id)
{
    int interval;
    int *shm_p, shm_id;
    key_t shm_key;

    if((shm_key = ftok(PATHNAME, proj_id)) == -1) {
        perror("ftok()");
        exit(1);
    }

    shm_id = shmget(shm_key, sizeof(int), 0);
    if(shm_id < 0)
    {
        perror("shmget()");
        exit(1);
    }

    //使用shmat将相关共享内存映射到本进程的内存地址
    shm_p = (int *)shmat(shm_id, NULL, 0);
    if((void *)shm_p == (void *)-1)
    {
        perror("shmat()");
        exit(1);
    }

    // critical section
    interval = *shm_p;
    interval++;
    usleep(1);
    *shm_p = interval;
    // critical section

    //使用shmdt解除本进程内存对共享内存的地址映射，本操作不会删除共享内存
    if(shmdt(shm_p) < 0){
        perror("shmdt()");
        exit(1);
    }

    exit(0);
}

int main()
{
    pid_t pid;
    int count;
    int *shm_p;
    int shm_id, proj_id;
    key_t shm_key;

    proj_id = 1234;

    if((shm_key = ftok(PATHNAME, proj_id)) == -1)
    {
        perror("ftok()");
        exit(1);
    }

    //使用shm_key创建一个共享内存，如果系统中已经存在此共享内存，则报错退出。创建出来的共享内存权限为0600
    shm_id = shmget(shm_key, sizeof(int), IPC_CREAT|IPC_EXCL|0600);
    if(shm_id < 0) {
        perror("shmget()");
        exit(1);
    }

    shm_p = (int *)shmat(shm_id, NULL, 0);
    if((void *)shm_p == (void *) -1)
    {
        perror("shmat()");
        exit(1);
    }

    *shm_p = 0;

    for(count = 0; count < COUNT; count++) {
        pid = fork();
        if(pid < 0) {
            perror("fork()");
            exit(1);
        }

        if(pid == 0) {
            do_child(proj_id);
        }
    }

    for(count = 0; count < COUNT; count ++) {
        wait(NULL);
    }

    printf("shm_p: %d\n", *shm_p);

    if(shmdt(shm_p) < 0) {
        perror("shmdt()");
        exit(1);
    }

    if(shmctl(shm_id, IPC_RMID, NULL) < 0) {
        perror("shmctl");
        exit(1);
    }

    exit(0);
}

在某些情况下，也可以不通过一个key来创建共享内存。此时可以在key的参数所在位置填IPC_PRIVATE,这样内核会在保证不冲突的共享内存段id的情况下新建一段共享内存。因为只能是创建，所以flag位一定是IPC_CREAT。可以将shmid传给子进程。

当获取到shmid之后，就可以使用shmat来进行地址映射。shmat之后，通过访问返回的当前进程的虚拟地址就可以访问到共享内存段了。注意使用之后要调用shmdt解除映射，否则对于长期运行的程序，可能会造成虚拟内存地址泄露。shmdt并不能删除共享内存段，只是解除共享内存段和进程虚拟地址的映射关系。只要shmid对应的共享内存段还存在，就可以使用shmat继续映射使用。想要删除一个共享内存段，需要使用shmctl的IPC_RMID指令处理，或者在命令行中使用ipcrm删除指定的共享内存id或key。

shmctl还可以查看、修改共享内存的相关属性，可以在man 2 shmctl中查看。在系统中还可以使用ipcs -m 命令查看系统中所有共享内存的信息。

ipcs - provide information on ipc facilities
ipcs [-asmq] [-tclup]
ipcs [-smq] -i id

-m 共享内存
-q 消息队列
-s 信号量数组
-a all（缺省）

输出选项：

-t time
-p pid
-c creator
-l limits
-u summary

在Linux系统中，使用XSI共享内存调用shmget时，可以通过设置shmflg参数来申请大页内存（huge pages）。

SHM_HUGETLB(since Linux 2.6)
SHM_HUGE_2MB, SHM_HUGE_1GB(since Linux 3.8)

使用大页内存的好处是提高内核对内存管理的处理效率。因为在相同内存大小的情况下，使用大页内存（2M一页）将比使用一般内存页（4K一页）的内存页管理的数量大大减少，从而减少内存页表项的缓存压力和CPU cache缓存内存地址的映射压力。但是需要注意一些地方：

大页内存不能交换（SWAP）
使用不当时可能造成更大的内存泄露
大页内存需要使用root权限
需要修改系统配置

shm_id = shmget(IPC_PRIVATE, MEMSIZE, SHM_HUGETLB|0600)

如果要申请2G以下的大页内存，需要系统预留2G以上的大页内存。

echo 2048 > /proc/sys/vm/nr_hugepages
cat /proc/meminfo | grep -i huge
    AnonHugePages:      841728 KB
    HugePages_Total:    2020
    HugePages_Free:     2020
    HugePages_Rsvd:     0
    HugePages_Surp:     0
    Hugepagesize:       2048 kB

2048是页数，每页2M。

还需要注意共享内存的限制：

echo 2147483648 > /proc/sys/kernel/shmmax
echo 33554432 > /proc/sys/kernel/shmall

/proc/sys/kernel/shmall：限制系统用在共享内存上的内存页总数。一页一般是4k（可以通过getconf PAGE_SIZE查看)

/proc/sys/kernel/shmmax：限制一个共享内存段的最大长度，单位是字节

/proc/sys/kernel/shmmni：限制整个系统可以创建的最大的共享内存段的个数

POSIX共享内存

POSIX共享内存实际上毫无新意，它本质上是mmap对文件的共享方式映射，只不过映射的是tmpfs文件系统上的文件。

tmpfs是将一部分内存空间用作文件系统，一般挂在/dev/shm目录。

Linux提供的POSIX共享内存，实际上就是在/dev/shm下创建一个文件，并将其mmap之后映射其内存地址即可。可以通过man shm_overview查看使用方法。

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
#include <string.h>
#include <sys/file.h>
#include <sys/wait.h>
#include <sys/mman.h>

#define COUNT 100
#define SHMPATH "shm"

int do_child(char * shmpath)
{
    int interval, shmfd, ret;
    int *shm_p;
    // 使用shm_open访问一个已经创建的POSIX共享内存
    shmfd = shm_open(shmpath, O_RDWR, 0600);
    if (shmfd < 0) {
        perror("shm_open()");
        exit(1);
    }

    // 用mmap将对应的tmpfs文件映射到本进程内存 */
    shm_p = (int *)mmap(NULL, sizeof(int), PROT_WRITE|PROT_READ, MAP_SHARED, shmfd, 0);
    if (MAP_FAILED == shm_p) {
        perror("mmap()");
        exit(1);
    }
    /* critical section */
    interval = *shm_p;
    interval++;
    usleep(1);
    *shm_p = interval;
    /* critical section */

    munmap(shm_p, sizeof(int));
    close(shmfd);

    exit(0);
}

int main()
{
    pid_t pid;
    int count, shmfd, ret;
    int *shm_p;

    /* 创建一个POSIX共享内存 */
    shmfd = shm_open(SHMPATH, O_RDWR|O_CREAT|O_TRUNC, 0600);
    if (shmfd < 0) {
        perror("shm_open()");
        exit(1);
    }
    /* 使用ftruncate设置共享内存段大小 */
    ret = ftruncate(shmfd, sizeof(int));
    if (ret < 0) {
        perror("ftruncate()");
        exit(1);
    }
    /* 使用mmap将对应的tmpfs文件映射到本进程内存 */
    shm_p = (int *)mmap(NULL, sizeof(int), PROT_WRITE|PROT_READ, MAP_SHARED, shmfd, 0);
    if (MAP_FAILED == shm_p) {
        perror("mmap()");
        exit(1);
    }
    *shm_p = 0;

    for (count=0;count<COUNT;count++) {
        pid = fork();
        if (pid < 0) {
            perror("fork()");
            exit(1);
        }

        if (pid == 0) {
            do_child(SHMPATH);
        }
    }

    for (count=0;count<COUNT;count++) {
        wait(NULL);
    }

    printf("shm_p: %d\n", *shm_p);
    munmap(shm_p, sizeof(int));
    close(shmfd);
    shm_unlink(SHMPATH);
    exit(0);
}

编译该段代码的时候需要指定一个库，-lrt，这是linux的real time库。

shm_open的SHMPATH参数是一个路径，这个路径默认放在系统的/dev/shm目录下。这是shm_open封装好的，保证文件一定在tmpfs下。
使用ftruncate改变共享内存的大小，实际就是改变文件的长度。
shm_unlink实际就是unlink系统调用的封装。如果不做unlink操作，那么文件会一直存在/dev/shm目录下。
关闭共享内存描述符，使用close.

修改共享内存内核配置

SHMMAX

一个进程可以在它的虚拟地址空间分配给一个共享内存端的最大大小（单位是字节）

echo 2147483648 > /proc/sys/kernel/shmmax
或
sysctl -w kernel.shmmax=2147483648
或
echo "kenerl.shmmax=2147483648" >> /etc/sysctl.conf

SHMMNI

系统范围内共享内存段的数量


echo 4096 > /proc/sys/kernel/shmmni
或
sysctl -w kernel.shmmni=4096
或
echo "kernel.shmmni=4096" >> /etc/sysctl.conf

SHMALL

这个参数设置了系统范围内共享内存可以使用的页数。单位是PAGE_SIZE（通常是4096，可以通过getconf PAGE_SIZE获得）。

echo 2097152 > /proc/sys/kernel/shmall
或
sysctl -w kernel.shmall=2097152
或
echo "kernel.shmall=2097152" >> /etc/sysctl.conf

移除共享内存

执行ipcs -m查看系统所有的共享内存。如果status字段是dest，表明这段共享内存需要被删除。

ipcs -m -i $shmid

mw_nice

关注

3
点赞
踩
10

收藏

觉得还不错? 一键收藏
0
评论
linux中几种共享内存

共享内存用处使用文件或者管道进行进程间通信会有很多局限性。管道只能在父进程和子进程间使用；通过文件共享，在处理效率上又差一些，而且访问文件描述符不如访问内存地址方便。Linux系统在编程上提供的共享内存方案有三种：mmap内存共享映射 XSI共享内存 POSIX共享内存mmap内存共享映射mmap本来是存储映射功能。它可以将一个文件映射到内存中，在程序里就可以直接使用内存地址...
复制链接

扫一扫